35

I am wondering if it is a good practice to use the same name for both a member variable and a function parameter in C++.

I come from a Java background, where this was common. I am wondering if in C++ there are drawbacks doing the following (the code works):

class Player
{
    public:
    void setState(PlayerState *state)
    {
        this->state = state;
    }

    private:
       PlayerState *state;
}

Thank you for the answers. As I understand while it works, a better practice would be to put some kind of marker to differentiate member variable from function parameters like: 

 _ or m_

In some editors (like Qt Designer), member variables are shows in a different color. This is why it did not seem necessary to add any prefixes.

Improve this question
6
  • 2
    Purely a matter of choice and conventions followed by the coding guidelines of your organization. Commented Apr 20, 2012 at 16:33
  • 2
    I don't think there is any indication apart from not having to write the this->. I always use some kind of underscore before of after, but it is a matter of taste. Commented Apr 20, 2012 at 16:33
  • Some people, start the attrib names with m, for example here will be mState, is better to do that way if the code is modified by someone else, ever the more readeable is your code, better Commented Apr 20, 2012 at 16:35
  • 1
    Careful with set/get members, or you'll end up with quasi-classes [PDF]. Commented Apr 20, 2012 at 16:37
  • I use a capitalized 'F' for 'Field', but that's just historical. If you use an initializer list, it's clearer what is being assigned to what, (unless it's C#, then you can't). Commented Apr 20, 2012 at 16:48

10 Answers 10

Reset to default
22

That is correct, and allowed by the Standard. But a better approach is to use some naming-convention for member variables. For example, you could use m_ prefix for all member variables, then anyone could infer what m_state is. It increases the readability of the code, and avoids common mistakes.

Also, if m_state is the member, then you don't have to write this->m_state = state in the member function, you could just write m_state = state. In your current code, this-> part becomes necessary, without which state = state will become self-assignment.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

What would happen if "this" is excluded (state=state)? That means function parameter probably takes more priority and hence class variable is not set I guess!
@Rajesh apart from in a c'tors initializer list: yes.
10

Normally people just put an underscore after the variable or use shorter less descriptive var names for the function parameter.

I personally do not like the same name thing because when reading it, it is easy to make mistakes.

Improve this answer

Comments

4

I find it a good choice to give member variables the same name as constructor initialization parameters.

Here are my reasons:

  • reduces the number of identifiers, hence reduces the complexity
  • you don't need to invent so many identifiers
  • same things should have same name if possible, that is logically speaking, I know
    parameter != member
  • contexts and indices can allow to give the same name to the same thing
  • you more easily find references (identifiers) to the logical thing by searching, if all references have the same name
Improve this answer

Comments

3

There is not really any difference between the C++ and Java, the only drawback is that you have to type this->state = state instead of state = arg.

But your code is perfectly acceptable, it's more of styling than anything else.

Improve this answer

Comments

1

I would suggest you to follow some coding style convention. Personally I use the:

class Player
{
    public:
    void setState(PlayerState *state)
    {
        _state = state;
    }

    private:
       PlayerState* _state;
}
Improve this answer

6 Comments

I personally I do like the the leading underscores as they are generally for the standard library and compiler functions. I do like the trailing underscores.
I don't like any underscores! With name-mangling, __attrib etc. I've seen enough underscores in C++ as it is!
All of these are depending on which coding styles your company is following. The leading underscore is quite common in many c# and java coding style guides :).
Also the lead underscore is allowed if it is not followed by the Capital letter. en.wikipedia.org/wiki/Naming_convention_(programming)
@AlexTheo Officially. In practice, you increase the risk of conflict with a leading underscore (and your never free from some compiler defining a symbol with no underscore---I've had problems with simply linux). More generally, leading and trailing underscores should be avoided because they're hard to see, and make reading the code more difficult. There's only one character difference between myState and _state, and the former is so much more readable.
|
1

This is more a style issue than anything else. Most of the time, there's no issue: state is a very poor name for a variable or a value, as variables and values should be qualified nouns, e.g.: 

void setState( PlayerState* newState )
{
    currentState = newState;
}

In theory, anyway. In practice, I've found it useful to use prefixes, along the lines of:

class Player
{
    PlayerState* myState;
public:
    void setState( PlayerState* newState )
    {
        myState = newState;
    }
};

When reading the code, if the name starts with my, it's clearly a member variable (and if it starts with our, it's a static member variable).

Note too that in the constructor, you can do things like:

Player::Player( PlayerState* state )
    : state( state )
{
}

I'm not sure what this does for readability, however:

Player::Player( PlayerState* initialState )
    : myState( initialState )
{
}

looks a lot clearer (but for simple data holders, the distinction might not be so significant).

Improve this answer

Comments

1

Please note that some compilers (vs 2015) may generate a warning if a variable shadows another. Off course, one can disable these kind of warnings. But I think it is good practice to have these checks enabled.

Improve this answer

Comments

1

If you use the member initializer list you can get away without using this->:

Demo

#include <cstdio>

struct mystruct
{
    mystruct(int a, bool b)
        :   a{a}
        ,   b{b}
    {}
    int a;
    bool b;
};


int main()
{
    mystruct s{1,true};
}

I use this for a simple struct which doesn't need a public private differentiation. I think it's good form bc for this case you can "imitate" aggregate initialization

mystruct s = { 1, true }

and have the constructor just appear to "route through" the entries to the according data members.

Improve this answer

1 Comment

Just to note that member initializer lists are C++11. See en.cppreference.com/w/cpp/language/constructor#Explanation
0

It's fine, in-fact it might even be good form, so long as it's only ever in your constructor.

Improve this answer

Comments

0

Do it this way:

class Player
{
    public:
    void setState(PlayerState *state)
    {
        this->m_state = state;
    }

    private:
       PlayerState *m_state;
}

You'll thank me some time later on. Haha.. (:

The "m_" ("Member") prefix distinguish members from functions and other stuff. Very useful with stuff like intellisense (or any other IDE auto-suggestion).

Also, mark m_state as const if you do not intend to change it later. Just in case.

Improve this answer

4 Comments

Making m_state const means that you can't support assignment.
@JamesKanze it actually depends where you put the const keyword - before the type, after it, or after the asterik etc' :)
Given that m_state has a pointer type, the only place you can put the const to make it const is after the *. Otherwise, you're not making m_state const, you're making what it points to const. (And if I were going to comment on something beyond the actual question, I'd ask why it was a pointer to begin with. PlayerState sounds like a value to me.)
@Poni actually, putting const before or after the type causes the same functionality (re-assignable pointer to constant PlayerState); after the asterisk is different (constant pointer to mutable PlayerState). Neither of these sound like a good idea for this example. Understanding const is prerequisite to using it.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.