我最近决定必须学习C/C++，但有一件事情我不太理解，那就是指针或者更准确地说是它们的定义。
这些例子怎么样：
int* test;int *test;int * test;int* test,test2;int *test,test2;int * test,test2;现在，据我所知，前三种情况都是一样的：Test 不是一个 int，而是指向 int 的指针。
第二组例子有点棘手。在 Case 4 中，test 和 test2 都将成为指向 int 的指针，而在 Case 5 中，只有 test 是指针，而 test2 是一个 "真正" 的 int。Case 6 呢？和 Case 5 一样吗？
4、5和6是相同的东西，只有test是一个指针。如果你想要两个指针，你应该使用：
int *test, *test2;
int* test;
int* test2;
星号周围的空格没有意义。以下三个表达式都表示相同的意思：
int* test;
int *test;
int * test;
int *var1;int var2;"int *var1;
int var2;
int *test的写法（http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Pointer_and_Reference_Expressions）。请保持一致。 - user2489252许多编码指南建议你每行只声明一个变量，这样可以避免任何混淆以及你在提问之前遇到的问题。我与之合作的大多数C ++程序员似乎都坚持这一点。
我知道这有点离题，但我发现有用的是反向阅读声明。
int* test; // test is a pointer to an int
当您开始声明const指针并且难以知道是指针是const，还是指针指向的内容是const时，这种方法非常有效。
int* const test; // test is a const pointer to an int
int const * test; // test is a pointer to a const int ... but many people write this as
const int * test; // test is a pointer to an int that's const
使用“顺时针螺旋规则”帮助解析C/C++声明;
遵循以下三个简单步骤:
从未知元素开始，沿着螺旋/顺时针方向移动; 遇到以下元素时，请将其替换为对应的英文语句：
[X]或[]: 数组大小为 X 或 数组大小未定义...
(type1, type2): 函数传递类型 type1 和 type2 并返回...
*: 指向... 的指针(s)- 保持在一个螺旋/顺时针方向上持续执行，直到覆盖所有记号。
- 始终优先解决括号中的内容！
此外，在可能的情况下（这在绝大多数情况下都是正确的），声明应该分成单独的语句。
int* x;风格而不是传统的int *x;风格。当然，空格对编译器来说并不重要，但它确实会影响人类。否认实际语法会导致样式规则，这可能会使读者感到恼怒和困惑。 - Adrian McCarthyint *arr [1] [2] [3] [4] 中，你的螺旋或左右在哪里？ - Peter - Reinstate Monicainttest;
inttest后面是标点符号;。它在这个阶段不会将int识别为一个单独的关键字（这在后续过程中发生）。因此，为了将该行读作一个名为test的整数声明，我们必须使用空格来分隔标识符标记。int test;
*字符不是任何标识符的一部分；它是一个独立的标记（标点符号）。因此，如果你写成：int*test;
int、*、test和;。因此，在指针声明中，空格并不重要，并且所有的int *test;
int* test;
int*test;
int * test;
unsigned long int a[10]={0}, *p=NULL, f(void);
unsigned long int，而声明符是a[10]={0}、*p=NULL和f(void)。声明符引入了被声明的事物的名称（a、p和f），以及关于该事物的数组性、指针性和函数性的信息。声明符还可以有一个相关的初始化器。
a的类型是"10个元素的unsigned long int数组"。这个类型由声明说明符和声明符的组合完全确定，并且初始值由初始化器={0}指定。同样，p的类型是"指向unsigned long int的指针"，同样由声明说明符和声明符的组合指定，并且初始化为NULL。根据同样的推理，f的类型是"返回unsigned long int的函数"。int[10] a;
[]运算符的操作数是a，而不是int。同样，在声明中也是如此。int* p;
乘法运算符的操作数是 p，而不是 int。但由于间接操作符是一元的且空格不重要，编译器不会报错，即使我们以这种方式书写。然而，它始终被解释为 int (*p);。
因此，如果你写成
int* p, q;
*的值为p，因此它将被解释为。int (*p), q;
int *test1, test2;
int* test1, test2;
int * test1, test2;
做同样的事情 - 在所有三种情况下，test1都是*运算符的操作数，因此具有类型"指向int的指针"，而test2的类型为int。
声明符可以变得任意复杂。你可以有指针数组：
T *a[N];
你可以有数组的指针：
T (*a)[N];
T *f(void);
T (*f)(void);
你可以有函数指针数组：
T (*a[N])(void);
T (*f(void))[N];
T 的指针。T *(*(*f(void))[N])(void); // yes, it's eye-stabby. Welcome to C and C++.
然后你有 信号：
void (*signal(int, void (*)(int)))(int);
这段文字的意思是
signal -- signal
signal( ) -- is a function taking
signal( ) -- unnamed parameter
signal(int ) -- is an int
signal(int, ) -- unnamed parameter
signal(int, (*) ) -- is a pointer to
signal(int, (*)( )) -- a function taking
signal(int, (*)( )) -- unnamed parameter
signal(int, (*)(int)) -- is an int
signal(int, void (*)(int)) -- returning void
(*signal(int, void (*)(int))) -- returning a pointer to
(*signal(int, void (*)(int)))( ) -- a function taking
(*signal(int, void (*)(int)))( ) -- unnamed parameter
(*signal(int, void (*)(int)))(int) -- is an int
void (*signal(int, void (*)(int)))(int); -- returning void
const int *p;
int const *p;
const int x = 1;
const int y = 2;
const int *p = &x;
p = &y;
*p = 3; // constraint violation, the pointed-to object is const
int * const p;
int x = 1;
int y = 2;
int * const p = &x;
*p = 3;
但你不能将p设置为指向不同的对象：
p = &y; // constraint violation, p is const
int 的指针数组，名为 ap，我们想要访问由第 i 个元素指向的 int 值。我们可以按以下方式访问该值：printf( "%d", *ap[i] );
表达式*ap[i]的类型是int；因此，ap的声明写成：
int *ap[N]; // ap is an array of pointer to int, fully specified by the combination
// of the type specifier and declarator
声明符 *ap[N] 的结构与表达式 *ap[i] 相同。运算符 * 和 [] 在声明中的行为与在表达式中相同 - [] 的优先级高于一元运算符 *，因此 * 的操作数是 ap[N]（它被解析为 *(ap[N])）。
作为另一个例子，假设我们有一个指向名为 pa 的 int 数组的指针，并且我们想要访问第 i 个元素的值。我们会这样写：
printf( "%d", (*pa)[i] );
(*pa)[i]的类型是int，因此声明应写为int (*pa)[N];
sizeof表达式这样的东西，我们在其中使用像(int *)或sizeof (int [10])之类的东西时，该如何阅读呢？我应该如何理解这样的内容？void foo( int *, int (*)[10] );
没有声明符号，* 和 [] 运算符直接修改类型吗？
嗯，并不是 - 仍然有一个声明符号，只是带有一个空标识符（称为抽象声明符）。如果我们用符号 λ 表示空标识符，那么我们可以将这些东西读作 (int *λ)，sizeof (int λ[10])，以及
void foo( int λ, int (*λ)[10] );
它们的行为与任何其他声明完全相同。int *[10]表示一个包含10个指针的数组，而int (*)[10]表示一个指向数组的指针。
T* p;
T* p, q;含义的问题，以及所有关于那些问题的重复问题等）；
3. 它在内部不一致 - 声明一个指针数组为T* a[N]与使用方式不对称（除非你习惯写* a[i]）；
4. 它不能应用于指向数组或函数的指针类型（除非你创建一个typedef来清晰地应用T* p约定，但...不推荐这样做）；
5. 这样做的原因 - "它强调了对象的指针性质" - 是站不住脚的。它不能应用于数组或函数类型，而我认为这些特性同样重要需要强调。T* p, q;）并不是其中之一。如果你正确地书写你的声明符号（T *p, q;），你就不太可能引起混淆。for循环都写成i = 0;
for( ; i < N; )
{
...
i++;
}
int &ref = x; - webninja正如其他人提到的，4、5和6是相同的。通常，人们使用这些示例来论证*应该与变量而不是类型相关联。虽然这是一种风格问题，但是否应该以这种方式思考和编写仍存在一些争议：
int* x; // "x is a pointer to int"
或者这样：
int *x; // "*x is an int"
顺便提一句，我属于第一种观点，但其他人为第二种形式辩护的原因是它（大多数时候）解决了这个特定问题：
int* x,y; // "x is a pointer to int, y is an int"
这可能会引起误解；相反你应该写
int *x,y; // it's a little clearer what is going on here
或者如果您真的想要两个指针，
int *x, *y; // two pointers
就我个人而言，我建议每行只定义一个变量，这样就不用担心你喜欢哪种风格了。
int *MyFunc(void)？是一个返回 int 的函数吗？不是的。显然我们应该写成 int* MyFunc(void)，并说 MyFunc 是一个返回 int* 的函数。所以对我来说很清楚，C 和 C++ 的语法解析规则在变量声明上是错的。它们应该将指针资格作为整个逗号序列的共享类型的一部分。 - v.oddou*MyFunc() 是一个 int。C 语法的问题在于混合使用前缀和后缀语法 - 如果仅使用后缀语法，就不会有混淆。 - Antti Haapala -- Слава Україніint const* x;，我认为这种写法会误导人，就像 a * x+b * y 一样。 - Adrian McCarthy#include <type_traits>
std::add_pointer<int>::type test, test2;
#include <windows.h>LPINT test, test2; - Stefan Dragnevtest和test2都是int*类型。 - undefined在4、5和6中，test始终是一个指针，而test2不是指针。在C++中，空格（几乎）从不重要。
char *a[100];
这段话说的是，*a[42] 将会是一个 char 类型。而 a[42] 则是一个指向 char 类型的指针。因此，a 是一个 char 指针数组。
这是因为最初的编译器作者希望在表达式和声明中使用相同的解析器。(这并不是一个非常明智的语言设计选择)
char* a[100];也可以推断出*a[42];将是一个char，而a[42];是一个字符指针。 - yynya[42]是一个char指针，而*a[42]是一个字符。 - Michel Billaud
++运算符不能用空格分开，标识符也不能用空格分开（编译器可能仍然合法但运行时行为未定义）。考虑到 C/C++ 的语法混乱，确切的情况很难定义。 - Sulthanint* test,test2;不能按照你的期望工作，这意味着它是错误的，是对语言的误解的结果，而int *test,test2;才是正确的。 - endolith