Identical Class Member Names and Function Argument Names in C++

Question

I have a simple object that holds some [public] data.

I want to keep my interface clean, so I don't want to pre-/post- fix anything to the names of the publically accessible variables nor to the names of my function arguments.

That said, I ended up doing something like this:

template<typename T> struct Foo
{
  explicit Foo(T x) : x(x) // This [i.e., x(x)] seems to be doing the "Right Thing", but is this well defined?
  {/*            ^ 
       No pre-/post- fixing.
   */
  }

  T x; // No pre-/post- fixing.
};

Just to reiterate: All I'm asking is whether this is well defined behavior. Not whether I should or shouldn't be doing this...

Thanks.

Answer 1

Yes, that's fine, and perfectly standard.

Local variables always come first in a name lookup, but the x(...) in an initialization list can obviously only refer to member variables [edit:or a base class].

If you didn't use the initialization list, you would have to write:

explicit Foo(T x)
{
    this->x = x;
}

Answer 2

Specifically for the initializer list of a ctor, it's well-defined behavior -- since you can only initialize a member or base class, there's no ambiguity between one of those and the name of a parameter.

Under almost any other circumstance, however, you'll create an ambiguity. In particular, your title simply refers to "function" -- and for any function other than the ctor, this won't work. Even inside the body of the ctor, it won't work -- the "special" treatment is purely within the initializer list of a ctor.

Answer 3

Don't use parameters that clash with member variables.
It may be OK at the language level, but it just makes it hard to read for humans.

The WHOLE point is to write code that is easy to read fro humans. The compiler will do just fine

template<typename T>
struct Foo 
{ 
   explicit Foo(T x_) // Wow hat a difference a single character does for readability.
       :x(x_)  
   {} 

    T x; 
};