<pre><code>
class C {
  T a;
public:
  C(T a): a(a) {;}
};
</code></pre>

<p>Is it legal?</p>

Yes it is legal and works on all platforms. 
It will correctly initialize your member variable a, to the passed in value a.
It is considered by some more clean to name them differently though, but not all.  I personally actually use it a lot :)
Initialization lists with the same variable name works because the syntax of an initialization item in an initialization list is as follows:
<member>(<value>)
You can verify what I wrote above by creating a simple program that does this:  (It will not compile)
```
```
class  A
{

   A(int a)
   : a(5)//<--- try to initialize a non member variable to 5
   {
   }
};
```
```
You will get a compiling error something like: A does not have a field named 'a'.
On a side note:
One reason why you
may not want
to use the same member name as parameter name is that you would be more prone to the following:
```
```
class  A
{

   A(int myVarriable)
   : myVariable(myVariable)//<--- Bug, there was a typo in the parameter name, myVariable will never be initialized properly
   {
   }
   int myVariable;
};
```
```
On a side note(2):
One reason why you
may want
to use the same member name as parameter name is that you would be less prone to the following:
```
```
class  A
{

   A(int myVariable_)
   {
     //<-- do something with _myVariable, oops _myVariable wasn't initialized yet
     ...
     _myVariable = myVariable_;
   }
   int _myVariable;
};
```
```
This could also happen with large initialization lists and you use _myVariable before initializing it in the initialization list.