Welcome to the Lounge

• char* c is preferred for C++. See (1).
• char *a, *b, *c; is sloppy - separate each declaration. See (2)
• For those arguing that pointers are not types, I would say that this amounts to arguing semantics (syntax?) at best. The C++ Standard (3) frequently talks about pointers as types. Moreover, operators dealing with the type system, such as typeid, decltype deal with pointers as types. The entire goal of smart pointers is to give types that can be transparently treated like pointers (along with additional behavior - object lifecycle mgmt., typically). Overloading, resolution, etc., all deal in "types" and pointers is part-and-parcel to this.
• (Practical usefulness) The "right to left" reading gives the intuitive type of a name. This works better than the "whitespace association" model. Consider:

  int* const volatile p1;  // p1 is a volatile const pointer to an int
  int *const volatile p2;  // (*const volatile p2) is an int?

• I'm declaring the name a to be a pointer to a MyObject, I'm not declaring the MyObject itself, I'm just declaring the pointer. To the point of my second bullet above, MyObject a, *b is nasty, because for a C++ programmer, the first variable is declaring an object, the second is declaring just a pointer. If the context of this is declaring local/global variables, the a involves a (potentially non-trivial) constructor, which entails who knows what. b is simply telling the compiler to reserve some bytes for a pointer. (Something similar can be said where these are fields of a class/struct/union.) These are wildly different things in C++.
  
  1. Stroustrup: C++ Style and Technique FAQ
  2. CppCoreGuidelines/CppCoreGuidelines.md at master · isocpp/CppCoreGuidelines · GitHub
  3. Working Draft, Standard for Programming
     Language C++

char *p;

T *p1, *p2, *p3;

int (*f(int x))[3]
{
    // ...
}

using T = char*;
T a, b;

.jpg wrote:

char is a type and c is a name, to me, it always make more sense to put the name alone and have the type together, like "char* c", I can tell immediately that it is a pointer to a char, so its always goes like [type] [name].

But in contrast, most C/C++ code I found prefer the other way around, like "char *c". Is there any specific reasons why this is so?

type varname;

char  c; // char is the type. c is var name
char* c; // char* is the type. c is the var name

double d;  // double is type. d is var name
float  f;  // float is type. f is var name

double* d;  // double* is type. d is var name
float*  f;  // float* is type. f is var name

int* a, b;

int (*a), b;

D *p;    // p is a pointer to D
D a[N];  // a is an array of D
D f();   // f is a function returning D

D *ap[N];  // ap is an array of pointers to D
D *fp();   // fp is a function returning a pointer to D

D (*pa)[N]; // pa is a pointer to an array of D
D (*pf)();  // pf is a pointer to a function returning D 

D (*fpa())[N];  // fpa is a function that returns a pointer to an array of D
D (*apf[N])();  // apf is an array of pointers to functions returning D

// even more complex combinations are possible!!!

Quote:

Mine can (in theory) ruin my PC

OriginalGriff wrote:

a big UPS to run their VAX. The lead/acid batteries exploded and sprayed the computer with sulphuric acid.

Quote:

So don't worry if I will be a bit quiet

RickZeeland wrote:

going to Sicily to pay my respects to "il padrone"