请注意，指针引用必须括在括号中，因为成员选择运算符比解引用操作符的优先级更高。
因为访问结构和类成员的指针是通过笨拙的语法，C++提供了一个二成员选择运算符（->）从指针做成员选择。以下两行是等价的：
1
2
3
4
5
6
7
8
9
10
struct Person
{
    int age;
    double weight;
};
Person person;
 
// Member selection using pointer to struct
Person *ptr = &person;
(*ptr).age= 5;
这个类有两个构造函数：一个默认构造函数，一个需要一个整数的构造函数。由于两个构造函数都要求“做一个”构造函数的一部分，所以在每个构造函数中都有代码被复制。

正如你现在（希望）学到的，有重复的代码是尽可能避免的东西，所以让我们看看一些方法来解决这个问题。

使用一个单独的函数

最显而易见的解决办法就是有foo（int）构造函数调用构造函数的foo()做的一部分。然而，与前C + + 11的编译器，如果你想有一个构造函数调用另一个构造函数，它会编译，但它不会做你期望的，你可能会花很长的时间，试图找出原因，即使调试器（事实证明，这实际上是创建一个临时对象然后丢弃它）。

然而，构造函数允许在类中调用非构造函数函数。只是要小心，任何成员的非构造函数的使用已经初始化。虽然你可能会被诱惑从第一个构造函数复制代码到第二个构造函数，有重复的代码，使你的类更难理解和更繁重的维护。这个问题的最好的解决方案是创建一个非构造函数的函数，该函数做了共同的初始化，并有两个构造函数调用该函数。

考虑到这一点，我们可以将上面的类更改为以下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Foo
{
private:
    void DoA()
    {
        // code to do A
    }
 
public:
    Foo()
    {
        DoA();
    }
 
    Foo(int nValue)
    {
        DoA();
        // code to do B
    }
 
};

注意指针解引用必须括在括号，因为成员选择运算符具有比解引用操作符的优先级更高的。

因为访问结构和类成员通过指针是笨拙的语法，C + +提供的第二个成员选择运算符（->）从指针做成员选择。下面的两行是等价的：



1

2




(*psSomething).nValue
 = 5;

psSomething->nValue
 = 5;


这不仅是容易的，但也更不容易出错因为没有优先的问题的担心。因此，在做成员访问通过指针，总是使用->操作符。




是的，这是可能的，更多的是比使用矢量更难。

当你说“动态大小的数组”，你想动态分配数组到一个特定的大小，或动态地调整现有的阵列？任何事都是可能的，但后者更难。

另外，如果你通过一个非const引用数组的函数，这意味着函数要修改数组。不需要返回一个引用返回给调用者，因为调用者可以通过它原来的名字访问数组。

在前面的课程中，你学到了局部变量（有块范围）和全局变量（有计划的范围）。还有另一个作用域的变量，可以水平：文件范围。

文件范围内的变量可以被访问的任何功能或嵌在一个单一的文件。申报文件作用域的变量，简单地声明一个变量，一块外（同一个全局变量）但使用static关键字：

同样，一个const引用的行为就像一个const指针指向const对象是隐式解引用。

因为引用总是“点”来有效的对象，而不能指出释放内存，引用的是比使用指针安全。如果一个任务可以通过引用或指针解决，参考一般应首选。指针通常只能用在引用是不充分的情况下（如动态分配的内存）。

成员的选择

通常有一个指针或引用一个结构（或类）。正如你已知道的，你可以选择使用一个struct的成员选择运算符成员（。）：

今天一天的时候都耗在了单链表的操作函数的编写上了，其实本来应该是一件很简单的事情，但是由于一个优先级的错误，导致了我调试了很久


先说下结论，结构体的二级指针在调用时，必须加上括号，因为*（取值）运算优先级是比->来的低的。


再来说下发现过程，写了很久的程序，产生了各种编译错误，排除好多粗心和手误的错误外，还有一个错误让我百思不得解，代码及错误提示为:
     错误代码： *L->Node = NULL;

     错误提示： [Error] request for member 'next' in something not a structure or union

当然这只是n多同类型错误中的一个，一开始我以为是函数调用的问题，就先将所有函数体都注释掉了，然后将一些涉及到这些错误的语句单独复制到主函数里，结果错误依旧存在。


后来各种查阅资料，无果，当然这里可能是我搜索的关键字不太对，因为我当时的目光一直盯在二级指针的内容上，我一开始始终认为是我的二级指针可能和某个一级指针弄混了，但现在想想，编译器并没有报这类的错误。


然后吃过晚饭，我尝试着将所有的二级指针单独拿出来，就是先定义一个一级指针，再把二级指针的内容赋给一级指针，再去操作一级指针，就像下面这样：

	struct Node *n;
	n = *L; //L为二级指针
	n->data = 0;
奇迹出现了，我这样写了之后，错误提示竟然消失了，这时我才意识到，可能是我在二级指针的调用上出了问题，于是去百度了“结构体二级指针的调用”，在CSDN的论坛的一个帖子里看到了这样的一行代码：
	(*ppA)->name = "ddddddd"


我恍然大悟，去查了一下C语言运算符的优先级列表，发现 * 的优先级果然没有 -> 高，顿觉自己像个白痴。。。。。。


经过这件事，我学到了以下几点：
1. * 的优先级没有 -> 高。
2.对于不知道优先级的运算，要加上括号才保险。
3.要多阅读他人的代码。


最后，附上C语言运算符优先级表：



优先级



运算符



名称或含义



使用形式



结合方向



说明



1


后置++


后置自增运算符



变量名++



左到右


 

后置--

后置自减运算符

变量名--

 


[ ]


数组下标


数组名[整型表达式]


 


( )



圆括号



（表达式）/函数名(形参表)


 


.



成员选择（对象）



对象.成员名


 


->



成员选择（指针）



对象指针->成员名


 


2



-



负号运算符



-表达式



右到左



单目运算符



(类型)



强制类型转换



(数据类型)表达式


 


前置++



前置自增运算符



++变量名



单目运算符



前置--



前置自减运算符



--变量名



单目运算符



*



取值运算符



*指针表达式



单目运算符



&



取地址运算符



&左值表达式



单目运算符



!



逻辑非运算符



!表达式



单目运算符



~



按位取反运算符



~表达式



单目运算符



sizeof



长度运算符



sizeof 表达式/sizeof(类型)


 


3



/



除



表达式/表达式



左到右



双目运算符



*



乘



表达式*表达式



双目运算符



%



余数（取模）



整型表达式%整型表达式



双目运算符



4



+



加



表达式+表达式



左到右



双目运算符



-



减



表达式-表达式



双目运算符



5



<<



左移



表达式<<表达式



左到右



双目运算符



>>



右移



表达式>>表达式



双目运算符



6



>



大于



表达式>表达式



左到右



双目运算符



>=



大于等于



表达式>=表达式



双目运算符



<



小于



表达式<表达式



双目运算符



<=



小于等于



表达式<=表达式



双目运算符



7



==



等于



表达式==表达式



左到右



双目运算符



!=



不等于



表达式!= 表达式



双目运算符



8



&



按位与



整型表达式&整型表达式



左到右



双目运算符



9



^



按位异或



整型表达式^整型表达式



左到右



双目运算符



10



|



按位或



整型表达式|整型表达式



左到右



双目运算符



11



&&



逻辑与



表达式&&表达式



左到右



双目运算符



12



||



逻辑或



表达式||表达式



左到右



双目运算符



13



?:



条件运算符



表达式1? 表达式2: 表达式3



右到左



三目运算符



14



=



赋值运算符



变量=表达式



右到左


 


/=



除后赋值



变量/=表达式


 


*=



乘后赋值



变量*=表达式


 


%=



取模后赋值



变量%=表达式


 


+=



加后赋值



变量+=表达式


 


-=



减后赋值



变量-=表达式


 


<<=



左移后赋值



变量<<=表达式


 


>>=



右移后赋值



变量>>=表达式


 


&=



按位与后赋值



变量&=表达式


 


^=



按位异或后赋值



变量^=表达式


 


|=



按位或后赋值



变量|=表达式


 


15



,



逗号运算符



表达式,表达式,…



左到右



从左向右顺序运算

                                                                                                              分清函数指针和指针函数
关于指针和数组斩不断理还乱的恩怨还真是说了不少，不过现在应该已经理清了。有了上一讲的基础，本讲的内容相对来说就比较容易理解了。
1．指向函数的指针(函数指针)
来分析这样一个声明，void (*f) ( );虽然()的优先级高于*，但由于有括号存在，首先执行的是解引用，所以f是一个指针；接下来执行( )，表明f指向一个函数，这个函数不返回任何值。现在得出结论：f是一个指向不接受参数且不返回任何值的函数的指针，简称函数指针(pointer to function)。
对比一下int(*p) [100]，p是一个指向含有100个整型元素的数组的指针，它们有一个共同的特点：指针声明符(*)和标识符(f或p)都被限制在一个括号中，由于括号的优先级是最高的，所以我们从标识符开始由内向外分析，即可得到以上结果。
<1>．初始化
注意指向函数的指针(函数指针)指向的是函数而非普通的变量，它所指向的函数也是有特定类型的，函数的类型由它的返回值类型以及形参列表确定，和函数名无关。对函数指针初始化时可以采用相同类型函数的函数名或函数指针(当然还有零指针常量)。假如有函数void test ( )，int wrong_match (int)和函数指针void (*ptf) ( )。
下面的初始化是错误的，因为函数指针的类型与函数的类型不匹配：
f = wrong_match;
f = & wrong_match;
ptf = wrong_match;
ptf = & wrong_match;
以下初始化及赋值是合法的：
f = test;
f = &test;
ptf = test;
ptf = &test;
f = pf;
要做出解释的是test和&test都可以用来初始化函数指针。C语言规定函数名会被转换为指向这个函数的指针，除非这个函数名作为& 操作符或sizeof操作符的操作数(注意：函数名用于sizeof的操作数是非法的)。也就是说f
 = test;中test被自动转换为&test，而f= &test;中已经显示使用了&test，所以test就不会再发生转换了。因此直接引用函数名等效于在函数名上应用 & 运算符，两种方法都会得到指向该函数的指针。
<2>．通过函数指针调用函数
通过函数指针调用函数可以有两种方法，直接使用函数指针或在函数指针前使用解引用运算符，如下所示：
f = test;
ptf = test;
f ( );
(*f) ( );  //指针两侧的括号非常重要，表示先对f解引用，然后再调用相应的函数
ptf ( );
(*ptf) ( ); //括号同样不能少
以上语句都能达到调用test函数的作用。ANSI C标准将f ( )认为是(*f)( )的简写形式，并且推荐使用f ( )形式，因为它更符合函数调用的逻辑。要注意的是：如果指向函数的指针没有初始化，或者具有0值(零指针常量)，那么该指针不能在函数调用中使用。只有当指针已经初始化，或被赋值后指向某个函数才能安全地用来调用函数。
<3>．探究函数名
现在有如下程序：
#include<stdio.h>
 
void test( )
{
    printf("test called!\n");
}
 
int main()
{
   void (*f) ( );
    f = test;

   f ( );

    (*f)( );
    //test++;             // error，标准禁止对指向函数的指针进行自增运算
          //test = test + 2;        //error，不能对函数名赋值，函数名也不能用于进行算术运算
          printf("%p\n", test);
          printf("%p\n", &test);
          printf("%p\n", *test);
  return 0;
}
在我机器上的运行结果为：
test called!
test called!
004013EE
004013EE
004013EE
这个程序中较难理解的是3个输出语句都可以得到函数的入口地址。首先来看函数名test，它与数组名类似(注意：只是类似)，是一个符号用来标识一个函数的入口地址，在使用中函数名会被转换为指向这个函数的指针，指针的值就是函数的入口地址，&test在前面已经说了：显示获取函数的地址。对于*test，可以认为由于test已经被转换成了函数指针,指向这个函数，所以*test就是取这个指针所指向的函数名，而又根据函数名会被转换指向该函数的指针的规则，这个函数也转变成了一个指针，所以*test最终也是一个指向函数test的指针。对它们采用%p格式项输出，都会得到以16进制数表示的函数test的入口地址。注意函数的地址在编译期是未知的，而是在链接时确定的。
2．返回指针的函数(指针函数)
类比指针数组(还记得吗)，理解指针函数将会更加轻松。所谓指针函数，就是返回指针的函数，函数可以不返回任何值，也可以返回整型值，实型值，字符型值，当然也可以返回指针值。一个指针函数的声明：int *f(int i, int j); 回想一下指针数组的声明：char *cars[10];同样的把它写成好理解的形式(非业界惯例)int* f(int i, int j);这样一来已经十分明了了，由于( )的优先级高于*，因此f先与()结合，所以f是一个具有两个int型参数，返回一个指向int型指针的函数。
C语言的库函数中有很多都是指针函数，比如字符串处理函数，下面给出一些函数原型：
char *strcat( char *dest, const char *src );
char *strcpy( char *dest, const char *src );
char *strchr( const char *s, int c );
char *strstr( const char *src, const char*sub );
注意函数的返回值不仅仅局限于指向变量的指针，也可以是指向函数的指针。初遇这种函数的声明可能会痛苦一点儿，但练习两三次应该是可以理解并掌握的。首先来看这个声明：int (*function(int)) (double*,char);要了解此声明的含义，首先来看function(int)，将function声明为一个函数，它带有一个int型的形式参数，这个函数的返回值为一个指针，正是我们本将开头讲过的函数指针int (*) (double*, char);这个指针指向一个函数，此函数返回int型并带有两个分别是double*型和char型的形参。如果使用typedef可以将这个声明简化：
typedef int (*ptf) (double*, char);
ptf function(int );
要说明一下，对于typedef int (*ptf) (double*,char); 注意不要用#define的思维来看待typedef，如果用#define的思维来看的话会以为(*ptf)(double*,
 char)是int的别名，但这样的别名看起来好像又不是合法的名字，于是会处于迷茫状态。实际上，上面的语句把ptf定义为一种函数指针类型的别名，它和函数指针类型int
 (*) (double*, char);等价，也就是说ptf现在也是一种类型。
3．函数指针和指针函数的混合使用
函数指针不仅可以作为返回值类型，还可以作为函数的形式参数，如果一个函数的形参和返回值都是函数指针，这个声明看起来会更加复杂，例如：
void (*signal (int sig, void (*func) (intsiga)) ) ( int siga );看上去确实有些恼人，我们来一步一步的分析。现在要分析的是signal，因为紧邻signal的是优先级最高的括号，首先与括号结合，所以signal为一个函数，括号内为signal的两个形参，一个为int型，一个为指向函数的指针。接下来从向左看，*表示指向某对象的指针，它所处的位置表明它是signal的返回值类型，现在可以把已经分析过的signal整体去掉，得到void (*) (
 int siga )，很清晰了吧。又是一个函数指针，这个指针与signal形参表中的第二个参数类型一样，都是指向接受一个int型形参且不返回任何值的函数的指针。同样地，用typedef可以将这个声明简化：
typedef void (*p_sig) (int);
p_sig signal(int sig, p_sig func);
这个signal函数是C语言的库函数，在signal.h中定义，用来处理系统中产生的信号，是UNIX/Linux编程中经常用到的一个函数，所以在此单独拿出来讲解一下。
4．函数指针数组
还有一种较为常用的关于函数指针的用法——函数指针数组。假设现在有一个文件处理程序，通过一个菜单按钮来选择相应的操作(打开文件，读文件，写文件，关闭文件)。这些操作都实现为函数且类型相同，分别为：
void open( );
void read( );
void write( );
void close( );
现在定义一个函数指针类型的别名PF：typedefvoid (*PF) ( );把以上4种操作取地址放入一个数组中，得到：
PF file_options[ ] = {
                &open,
                &read,
                &write,
                &close
};
这个数组中的元素都是指向不接受参数且不返回任何值的函数的指针，因此这是一个函数指针数组。接下来，定义一个函数指针类型的指针action并初始化为函数指针数组的第一个元素：PF* action = file_options;，如果不好理解，可以类比一下int ia[4] = {0, 1, 2, 3}; int *ip = ia;，这里PF相当于int，这样应该比较好懂了。通过对指针action进行下标操作可以调用数组中的任一操作，如：action[2]( )会调用write操作，以此类推。在实际中，指针action可以和鼠标或者其他GUI对象相关联，以达到相应的目的。
5．关于指针的复杂声明
第4点中的函数指针数组采用了typedef来声明，这是应该提倡的方法，因为它可读性更高。如果不使用typedef，那么分析起来就会比较复杂，结果是void (*file_options[ ]) ( );对于C语言的复杂声明我不想讲太多，因为在实际中用到的机会并不多，并且推荐大家多用typedef来简化声明的复杂度。对于分析复杂声明有一个极为有效的方法——右左法则。右左法则的大致描述为：从未定义的变量名开始阅读声明，先向右看，然后向左看。当遇到括号时就调转阅读的方向。括号内的所有内容都分析完毕就跳出括号。这样一直继续下去，直到整个声明都被分析完毕。来分析一个的例子：int
 * (* (*fp) (int) ) [10]; 
阅读步骤：
1．从未定义的变量名开始阅读 --------------------------------------------fp
2．往右看，什么也没有，遇到了)，因此往左看，遇到一个* ------一个指向某对象的指针
3．跳出括号，遇到了(int) -----------------------------------一个带一个int参数的函数
4．向左看，发现一个* ---------------------------------------（函数）返回一个指向某对象的指针
5．跳出括号，向右看，遇到[10] ------------------------------一个10元素的数组
6．向左看，发现一个* ---------------------------------------一个指向某对象指针
7．向左看，发现int -----------------------------------------int类型
所以fp是指向函数的指针,该函数返回一个指向数组的指针，此数组有10个int*型的元素。


对此我不再多举例了，下面给出一些声明，有兴趣的朋友可以试着分析一下，答案我会在下一讲中给出：
1． int *( *( *a[5]) ( ) ) ( );
2． void * (*b) ( char, int (*) ( ) );
3． float ( *(*c[10]) (int*) ) [5]; 
4． int ( *(*d)[2][3] ) [4][5];
5． int (*(*(*e) ( int* ))[15]) (int*);
6． int ( *(*f[4][5][6]) (int*) ) [10];
7． int *(*(*(*g)( ))[10]) ( );
 
前言
1.指针到底是什么
2.指针的定义及运算
3.指针与数组的“爱恨情仇”
5.指针与结构
6.使用指针时的“陷阱”
后记


转：http://blog.csdn.net/porscheyin/article/details/3461632