Declaring pointers; asterisk on the left or right of the space between the type and name?
It's a matter of preference, and somewhat of a holy war, just like brace style.
The "C++" style
someType* somePtr;
is emphasizing the type of the pointer variable. It is saying, essentially, "the type of somePtr
is pointer-to-someType
".
The "C" style
someType *somePtr;
is emphasizing the type of the pointed-to data. It is saying, essentially, "the type of data pointed to by somePtr
is someType
".
They both mean the same thing, but it depends on if a given programmer's mental model when creating a pointer is "focused", so to speak, on the pointed-to data or the pointer variable.
Putting it in the middle (as someType * somePtr
) is trying to avoid committing to either one.
Placement of the asterisk in pointer declarations
4, 5, and 6 are the same thing, only test is a pointer. If you want two pointers, you should use:
int *test, *test2;
Or, even better (to make everything clear):
int* test;
int* test2;
Type Declaration - Pointer Asterisk Position
Stroustrup was asked this and he said (paraphrasing)
- if you think more C-ish you will say int *a and Employee *pE
(so in your head you're thinking "the content of a is an integer")- if you think more C++-ish you will say int* a and Employee* pE
(so in your head it's "a is an integer pointer")
You can think however you like, as long as you never declare two
pointers on the same line.
Works for me. I'm an Employee* pE
kind of person, but I'm married to an Employee *pE
kind of person - my advice would be not to get too worked up about it.
What is the difference between Type *Name and Type* Name?
C compiler ignores the whitespace (except whitespace inside character constants and string literals).
It means that
int * p;
int*p;
int* p;
int *p;
int * p ;
mean exactly the same.
The white space is only important in macros for example:
#define a(x) ((x)+(x))
#define a (x) ((x)+(x))
mean something completely different.
C++ style: Stroustrup' s placement of pointer asterisks
C++ emphasis heavily on types and when it comes to pointers declaration, to avoid any sort of confusion, Bjarne suggested - Stick to one pointer per declaration
.
From Bjarne Stroustrup's C++ Style and Technique FAQ [emphasis added]:
Is
int* p;
right or isint *p;
right?Both are "right" in the sense that both are valid C and C++ and both have exactly the same meaning. As far as the language definitions and the compilers are concerned we could just as well say
int*p;
orint * p;
The choice between
int* p;
andint *p;
is not about right and wrong, but about style and emphasis. C emphasized expressions; declarations were often considered little more than a necessary evil. C++, on the other hand, has a heavy emphasis on types.A
typical C programmer
writesint *p;
and explains it*p is what is the int
emphasizing syntax, and may point to the C (and C++) declaration grammar to argue for the correctness of the style. Indeed, the*
binds to the namep
in the grammar.A
typical C++ programmer
writesint* p;
and explains itp is a pointer to an int
emphasizing type. Indeed the type ofp
isint*
. I clearly prefer that emphasis and see it as important for using the more advanced parts of C++ well.The critical confusion comes (only) when people try to declare several pointers with a single declaration:
int* p, p1; // probable error: p1 is not an int*
Placing the
*
closer to the name does not make this kind of error significantly less likely.
int *p, p1; // probable error?
Declaring one name per declaration minimizes the problem - in particular when we initialize the variables. People are far less likely to write:
int* p = &i;
int p1 = p; // error: int initialized by int*
And if they do, the compiler will complain.
Whenever something can be done in two ways, someone will be confused. Whenever something is a matter of taste, discussions can drag on forever. Stick to one pointer per declaration and always initialize variables and the source of confusion disappears.See The Design and Evolution of C++ for a longer discussion of the C declaration syntax.
clang-format: Align asterisk (*) of pointer declaration with variable name
It's fixed now!
The review https://reviews.llvm.org/D27651 has been re-applied in https://reviews.llvm.org/D103245 and committed in https://reviews.llvm.org/rG3e333cc82e42e1e2ecc974d896489eebe1a5edc2.
This change will be included in LLVM 13 release.
Why is the asterisk before the variable name, rather than after the type?
They are EXACTLY equivalent.
However, in
int *myVariable, myVariable2;
It seems obvious that myVariable has type int*, while myVariable2 has type int.
In
int* myVariable, myVariable2;
it may seem obvious that both are of type int*, but that is not correct as myVariable2
has type int.
Therefore, the first programming style is more intuitive.
What is the difference between `char **argv` and `char** argv`?
If so, then what is char** argv?
If (also) declares argv
to be a pointer to a pointer to a char.
What is the difference between
char **argv
andchar** argv
?
The difference between them is the placement of space. There is no other difference. These are also the same:
char**argv
char * * argv
char
*
*
argv
The asterisk in Objective-C object instance declarations: by the Object or by the instance?
It doesn't make a difference, but there are good reasons to put it in each place:
It makes sense to put it near the class, because that makes it feel like a type:
NSString*
, a pointer to a string. Sensible.It makes sense to put it near the variable, because that's what's actually happening:
*
is dereference. When you dereference your pointerstring
, you get anNSString
.*string
is anNSString
. Sensible.
You may want to go with the latter because that's the way the compiler is thinking, so: NSString* oneString, anotherString
will not work, whereas NSString *oneString, *anotherString
is correct.
Related Topics
Opengl Object in C++ Raii Class No Longer Works
How to Make a Simple C++ Makefile
Fastest Method of Screen Capturing on Windows
Pointer Expressions: *Ptr++, *++Ptr and ++*Ptr
When Does a Process Get Sigabrt (Signal 6)
C/C++ Macro String Concatenation
Opencv Point(X,Y) Represent (Column,Row) or (Row,Column)
C and C++: Partial Initialization of Automatic Structure
Is "For(;;)" Faster Than "While (True)"? If Not, Why Do People Use It
Qt Linker Error: "Undefined Reference to Vtable"
Opengl - How to Create Order Independent Transparency
How to Generate Different Random Numbers in a Loop in C++
How to Solve the 32-Byte-Alignment Issue For Avx Load/Store Operations
Initialization Order of Class Data Members
C++ "Virtual" Keyword For Functions in Derived Classes. Is It Necessary