C++ Style Question

[Nemanja Trifunovic]

I use the former style, mostly because I learned C++ from the Stroustrup's book, and that's what he does. BTW, there is another style you didn't mention:

CType * Pointer = NULL;

Programming Blog utf8-cpp

[Nish Nishant]

For single variable declarations I'd do :

int* p1;
int* p2;

But for multiple variables this may result in confusion, for example :

int* p1, p2;

There, p1 is an int* but p2 is actually an int. So in such cases I'd write :

int *p1, *p2;

Of course as far as possible I would avoid multiple variable declarations. That's just not my style.

Regards, Nish

---

Nish’s thoughts on MFC, C++/CLI and .NET (my blog)
My latest book : C++/CLI in Action / Amazon.com link

[Lost User]

I prefer the first. Same with references:

Object& obj = someFunc();

as opposed to:

Object &obj = someFunc();

[Chris Losinger]

i always use the 2nd, out of habit. the first would be clearer except you can do this:

CType* ptr, nonPtr;

but the * doesn't apply to all items in the var list. therefore it's not really part of the type, it's really tied to the individual variable. but that's not why i don't use it.

image processing toolkits | batch image processing

[0x3c0]

I prefer the latter, because in my mind, Pointer is already a CType. The asterisk simply adds the notice that the variable just points to a CType, instead of actually being the CType. Plus, it looks a little neater

Between the idea And the reality Between the motion And the act Falls the Shadow

[Hans Dietrich]

What if you wanted to declare both a non-pointer and a pointer to CType on the same line? [Not something I favor, but nevertheless legal]. In other words, take the two lines

CType* v1;
CType v2;

and combine them into one line. If you wrote the one line like this:

CType* v1, v2; // only v1 is pointer

I think it would be natural (and also incorrect) to think that both v1 and v2 were pointers to CType, whereas if you always associate the dereference operator with the variable, this confusion may be minimized:

CType *v1, v2; // only v1 is pointer

Best wishes, Hans

---

[Hans Dietrich Software]

[Dan Neely]

I've been burned by multiple declarations enough that I always put the * on the variable name for clarity.

It is a truth universally acknowledged that a zombie in possession of brains must be in want of more brains. -- Pride and Prejudice and Zombies

[Single Step Debugger]

I call this style the “MindChanger”.

The narrow specialist in the broad sense of the word is a complete idiot in the narrow sense of the word. Advertise here – minimum three posts per day are guaranteed.

[kinar]

this is how I do it.

[Single Step Debugger]

I prefer the second declaration – asterisk next to the variable name for both primitives and objects. The reason is that I very much like the pointers and I don’t want to insult them giving their asterisk to the type. :)

The narrow specialist in the broad sense of the word is a complete idiot in the narrow sense of the word. Advertise here – minimum three posts per day are guaranteed.

[PIEBALDconsult]

I prefer the first because it expresses the intent more clearly, but it's "incorrect" for the reason mentioned by others. It's because of this that I never declare multiple variables in one statement. Another thing I'll need to discuss with dmr when I get my time machine working... :~

[Richard Andrew x64]

You've directly hit upon my dilemma. The multiple declaration exposes the fact that the asterisk is an attribute of the variable, not the type proper. However, in a single declaration, it somehow makes a lot of sense to indicate that you're declaring a type-pointer. :confused:

[Big Daddy Farang]

Nishant Sivakumar wrote:

avoid multiple variable declarations

Dr. Plum and I agree. :)

BDF People don't mind being mean; but they never want to be ridiculous. -- Moliere

[Big Daddy Farang]

What I was taught in my first C++ class is:

CType* Pointer = NULL; // proper style for C++

CType *Pointer = NULL; // proper style for C

Although this may be the instructor's opinion. It's what I've been doing ever since, however.

BDF People don't mind being mean; but they never want to be ridiculous. -- Moliere

[Kevin McFarlane]

First for same reason as Joe Woodbury.

Kevin

[Kevin McFarlane]

Ditto.

Kevin

[Luc Pattyn]

You can solve the problem by dropping the space. More seriously, putting more than one variable in the declaration (one pointer, one not) should show the way to do it. :)

Luc Pattyn [Forum Guidelines] [My Articles]

---

The quality and detail of your question reflects on the effectiveness of the help you are likely to get. Show formatted code inside PRE tags, and give clear symptoms when describing a problem.

---

[Anna Jayne Metcalfe]

Ditto. The second one always looks like a dereference to me - which it isn't.

Anna :rose: Having a bad bug day? Tech Blog | Anna's Place | Tears and Laughter "If mushy peas are the food of the devil, the stotty cake is the frisbee of God"

[Anna Jayne Metcalfe]

I avoid multiple pointer declarations on the same line as I always initialise them (never leave them dangling):

int* p1 = NULL;
int* p2 = NULL;

Anna :rose: Having a bad bug day? Tech Blog | Anna's Place | Tears and Laughter "If mushy peas are the food of the devil, the stotty cake is the frisbee of God"

[Stuart Dootson]

I prefer the first one's aesthetics - but it can hide the way C type-decls are actually decoded, and as Nish said, the multiple item declaration thing is an issue. The other alternative, of course, is to encapsulate the pointer-ness in a typedef:

typedef CType* CTypePtr;
CTypePtr Pointer = NULL;

Helps especially with function pointers - which is easier to understand:

int (*myFn)(double, int);

or

typedef int (*MyFnPtr)(double, int);

MyFnPtr myFn;

? I guess some amount of the SPARK Ada development I've done (SPARK doesn't allow anonymous type defs) has rubbed off on me. Who'da thunk it...

Java, Basic, who cares - it's all a bunch of tree-hugging hippy cr*p