const static 数组指针

最新推荐文章于 2024-09-08 01:29:12 发布

丛林溪水鱼

最新推荐文章于 2024-09-08 01:29:12 发布

阅读量3.1k

点赞数

分类专栏：编程语言

编程语言专栏收录该内容

5 篇文章 0 订阅

订阅专栏

const类型定义：指明变量或对象的值是不能被更新,引入目的是为了取代预编译指令

常量必须被初始化***********

cons的作用
   （1）可以定义const常量         例如：
             const int Max=100;
             int Array[Max];
   （2）便于进行类型检查            例如：
             void f(const int i) { .........}
        编译器就会知道i是一个常量，不允许修改；
   （3）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。
        还是上面的例子，如果在函数体内修改了i，编译器就会报错；
        例如：
             void f(const int i) { i=10;//error! }
    (5) 为函数重载提供了一个参考。
         class A
         {
           ......
           void f(int i)       {......} file://一个函数
           void f(int i) const {......} file://上一个函数的重载
            ......
          };
     (6) 可以节省空间，避免不必要的内存分配。
         例如：
              #define PI 3.14159         file://常量宏
              const doulbe  Pi=3.14159;  file://此时并未将Pi放入ROM中
              ......
              double i=Pi;               file://此时为Pi分配内存，以后不再分配！
              double I=PI;               file://编译期间进行宏替换，分配内存
              double j=Pi;               file://没有内存分配
              double J=PI;               file://再进行宏替换，又一次分配内存！
         const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
     （7）提高了效率。
           编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

使用const
   （1）修饰一般常量,常数组，常对象
　　修饰符const可以用在类型说明符前，也可以用在类型说明符后。      例如：
           int const x=2;　　或　　const int x=2;

　　     int const a[5]={1, 2, 3, 4, 5};    或  const int a[5]={1, 2, 3, 4, 5};

           class A;　     const A a;  或     A const a;
　　
   （2）修饰指针
        const int A;   或  int const A; //const修饰指向的对象，A可变，A指向的对象不可变
        int const A; 　            //const修饰指针A，     A不可变，A指向的对象可变
        const int const A;      //指针A和A指向的对象都不可变
   （3）修饰引用
　　     const double & v;      该引用所引用的对象不能被更新
　（4）修饰函数的返回值：
        const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下：
            const int Fun1();
            const MyClass Fun2();
   （5）修饰类的成员函数：
        const修饰符也可以修饰类的成员函数，格式如下：
            class ClassName
     {
             public:
            　    　int Fun() const;
            　       .....
             }；
        这样，在调用函数Fun时就不能修改类里面的数据
    （6）在另一连接文件中引用const常量
         extern const int i;     //正确的引用
         extern const int j=10;  //错误！常量不可以被再次赋值


*******************放在类内部的常量有什么限制？

        class A
        {
         private:
           const int c3 = 7;               // err
           static int c4 = 7;               // err
           static const float c5 = 7;  // err
          ......
  };
初始化类内部的常量
        1 初始化列表：
         class A
         {
          public:
                A(int i=0):test(i) {}
          private:
                const int i;
          }；
         2 外部初始化，例如：
         class A
         {
          public:
                A() {}
          private:
                static const int i;
          }；
          const int A::i=3;

请按义项进行编辑

CONST

添加义项 设置这是一个多义词，请在下列义项中选择浏览

1．C中的CONSTC中的CONST
2．C++中CONSTC++中CONST
3．PHP5中的CONSTPHP5中的CONST
4．C#.net中的constC#.net中的const
5．const在HC08C语言中的含义const在HC08C语言中的含义

1.C中的CONST

编辑本义项

CONST

求助编辑百科名片

const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性，另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一些帮助。另外CONST在其他编程语言中也有出现，如C++、PHP5、C#.net、HC08 C。

　　C中CONST的使用：

　　虽然这听起来很简单，但实际上，const的使用也是c语言中一个比较微妙的地方，微妙在何处呢？请看下面几个问题。

　　问题：const变量 & 常量

　　为什么下面的例子在使用一个const变量来初始化数组，ANSI C的编译器会报告一个错误呢？　

　　const int n = 5;

　　int a[n];

　　答案与分析:

　　1）、这个问题讨论的是“常量”与“只读变量”的区别。常量肯定是只读的，例如5， "abc"，等，肯定是只读的，因为常量是被编译器放在内存中的只读区域，当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符（Qualifier）。上述代码中变量n被修饰为只读变量，可惜再怎么修饰也不是常量。而ANSI C规定数组定义时长度必须是“常量”，“只读变量”也是不可以的。

　　2)、注意：在ANSI C中，这种写法是错误的，因为数组的大小应该是个常量，而const int n,n只是一个变量（常量 != 不可变的变量，但在标准C++中，这样定义的是一个常量，这种写法是对的），实际上，根据编译过程及内存分配来看，这种用法本来就应该是合理的，只是 ANSI C对数组的规定限制了它。

　　3)、那么，在ANSI C 语言中用什么来定义常量呢？答案是enum类型和#define宏，这两个都可以用来定义常量。

　　问题：const变量 & const 限定的内容

　　下面的代码编译器会报一个错误，请问，哪一个语句是错误的呢？　

　　typedef char * pStr;

　　char string[4] = "abc";

　　const char *p1 = string;

　　const pStr p2 = string;

　　p1++;

　　p2++;

　　答案与分析：

　　问题出在p2++上。

　　1)、const使用的基本形式： const char m;

　　限定m不可变。

　　2)、替换1式中的m, const char *pm;

　　限定*pm不可变，当然pm是可变的，因此问题中p1++是对的。

　　3)、替换1式char, const newType m;

　　限定m不可变，问题中的charptr就是一种新类型，因此问题中p2不可变，p2++是错误的。

　　问题：const变量 & 字符串常量

　　请问下面的代码有什么问题？

　　char *p = "i'm hungry!";

　　p[0]= 'I';

　　答案与分析：

　　上面的代码可能会造成内存的非法写操作。分析如下， "i'm hungry"实质上是字符串常量，而常量往往被编译器放在只读的内存区，不可写。p初始指向这个只读的内存区，而p[0] = 'I'则企图去写这个地方，编译器当然不会答应。

　　问题：const变量 & 字符串常量2

　　请问char a[3] = "abc" 合法吗？使用它有什么隐患？

　　答案与分析：

　　在标准C中这是合法的，但是它的生存环境非常狭小；它定义一个大小为3的数组，初始化为"abc"，注意，它没有通常的字符串终止符'\0'，因此这个数组只是看起来像C语言中的字符串，实质上却不是，因此所有对字符串进行处理的函数，比如strcpy、printf等，都不能够被使用在这个假字符串上。

　　问题5：const & 指针

　　类型声明中const用来修饰一个常量，有如下两种写法，那么，请问，下面分别用const限定不可变的内容是什么?

　　1)、const在前面

　　const int nValue； //nValue是const

　　const char *pContent; //*pContent是const, pContent可变

　　const (char *) pContent;//pContent是const,*pContent可变

　　char* const pContent; //pContent是const,*pContent可变

　　const char* const pContent; //pContent和*pContent都是const

　　2)、const在后面，与上面的声明对等

　　int const nValue； // nValue是const

　　char const * pContent;// *pContent是const, pContent可变

　　(char *) const pContent;//pContent是const,*pContent可变

　　char* const pContent;// pContent是const,*pContent可变

　　char const* const pContent;// pContent和*pContent都是const

　　答案与分析：

　　const和指针一起使用是C语言中一个很常见的困惑之处，在实际开发中，特别是在看别人代码的时候，常常会因为这样而不好判断作者的意图，下面讲一下我的判断原则：

　　（这个规则是错的）(因为“（）”的出现，使得这个规则有时候是不成立的)沿着*号划一条线，如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。你可以根据这个规则来看上面声明的实际意义，相信定会一目了然。

　　另外，需要注意：对于const (char *) ; 因为char *是一个整体，相当于一个类型(如 char)，因此，这时限定指针是const。

　　一个简单的判断方法：指针运算符*，是从右到左，那么如：char const * pContent，可以理解为char const (* pContent)，即* pContent为const，而pContent则是可变的。

拆分词条

static

求助编辑百科名片

像在VB，C，C++，Java中我们可以看到static作为关键字和函数出现，在其他的高级计算机语言如FORTRAN、ALGOL、COBOL、BASIC、LISP、SNOBOL、PL/1、Pascal、PROLOG、Ada等语言中也是有出现的，只是有着不同的作用，对于其具体作用，读者有需要的时候是可以具体查阅的鉴于时间问题今天我就不一一罗列了。

编辑本段C++中的static

简介

　　C++的static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。

面向过程设计中的static

　　1、静态全局变量

　　在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下：

　　//Example 1

　　#include <iostream.h>

　　void fn();

　　static int n; //定义静态全局变量

　　void main()

　　{ n=20;

　　cout<<n<<endl;

　　fn();

　　}

　　void fn()

　　{ n++;

　　cout<<n<<endl;

　　}

　　静态全局变量有以下特点：

x　　静态全局变量不能被其它文件所用；

　　其它文件中可以定义相同名字的变量，不会发生冲突；

　　您可以将上述示例代码改为如下：

　　//Example 2//File1

　　#include <iostream.h>

　　void fn();

　　static int n; //定义静态全局变量

　　void main()

　　{ n=20;

　　cout<<n<<endl;

　　fn();

　　}

　　//File2

　　#include <iostream.h>

　　extern int n;

　　void fn()

　　{ n++;

　　cout<<n<<endl;

　　}

　　编译并运行Example 2，您就会发现上述代码可以分别通过编译，但运行时出现错误。试着将

　　static int n; //定义静态全局变量

　　改为

　　int n; //定义全局变量

　　再次编译运行程序，细心体会全局变量和静态全局变量的区别。

　　 注意：全局变量和全局静态变量的区别

　　1）全局变量是不显式用static修饰的全局变量，但全局变量默认是静态的，作用域是整个工程，在一个文件内定义的全局变量，在另一个文件中，通过extern 全局变量名的声明，就可以使用全局变量。

　　2）全局静态变量是显式用static修饰的全局变量，作用域是所在的文件，其他的文件即使用extern声明也不能使用。

　　2、静态局部变量

　　在局部变量前，加上关键字static，该变量就被定义成为一个静态局部变量。

　　我们先举一个静态局部变量的例子，如下：

　　//Example 3

　　#include <iostream.h>

　　void fn();

　　void main()

　　{ fn();

　　fn();

　　}

　　void fn()

　　{ static int n=10;

　　cout<<n<<endl;

　　n++;

　　}

　　通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。

　　但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。

　　静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。

　　静态局部变量有以下特点：

　　该变量在全局数据区分配内存；

　　静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；

　　静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；

　　它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；

　　3、静态函数

　　在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

　　静态函数的例子：

　　//Example 4

　　#include <iostream.h>

　　static void fn();//声明静态函数

　　void main()

　　{

　　fn();

　　}

　　void fn()//定义静态函数

　　{ int n=10;

　　cout<<n<<endl;

　　}

　　定义静态函数的好处：

　　静态函数不能被其它文件所用；

　　其它文件中可以定义相同名字的函数，不会发生冲突；

面向对象的static关键字

　　（类中的static关键字）

　　1、静态数据成员

　　在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

　　//Example 5

　　#include <iostream.h>

　　class Myclass

　　{

　　public:

　　Myclass(int a,int b,int c);

　　void GetSum();

　　private:

　　int a,b,c;

　　static int Sum;//声明静态数据成员

　　};

　　int Myclass::Sum=0;//定义并初始化静态数据成员

　　Myclass::Myclass(int a,int b,int c)

　　{ this->a=a;

　　this->b=b;

　　this->c=c;

　　Sum+=a+b+c;}

　　void Myclass::GetSum()

　　{ cout<<"Sum="<<Sum<<endl;

　　}

　　void main()

　　{ Myclass M(1,2,3);

　　M.GetSum();

　　Myclass N(4,5,6);

　　N.GetSum();

　　M.GetSum();}

　　可以看出，静态数据成员有以下特点：

　　对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；

　　静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；

　　静态数据成员和普通数据成员一样遵从public,protected,private访问规则；

　　因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；

　　静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：

　　<数据类型><类名>::<静态数据成员名>=<值>

　　类的静态数据成员有两种访问形式：

　　<类对象名>.<静态数据成员名> 或 <类类型名>::<静态数据成员名>

　　如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员；

　　静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；

　　同全局变量相比，使用静态数据成员有两个优势：

　　静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；

　　可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

　　2、静态成员函数

　　与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this 是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

　　//Example 6

　　#include <iostream.h>

　　class Myclass

　　{public:

　　Myclass(int a,int b,int c);

　　static void GetSum();/声明静态成员函数

　　private:

　　int a,b,c;

　　static int Sum;//声明静态数据成员

　　};

　　int Myclass::Sum=0;//定义并初始化静态数据成员

　　Myclass::Myclass(int a,int b,int c)

　　{ this->a=a;

　　this->b=b;

　　this->c=c;

　　Sum+=a+b+c; //非静态成员函数可以访问静态数据成员

　　}

　　void Myclass::GetSum() //静态成员函数的实现

　　{// cout<<a<<endl; //错误代码，a是非静态数据成员

　　cout<<"Sum="<<Sum<<endl;

　　}

　　void main()

　　{ Myclass M(1,2,3);

　　M.GetSum();

　　Myclass N(4,5,6);

　　N.GetSum();

　　Myclass::GetSum();

　　}

　　关于静态成员函数，可以总结为以下几点：

　　出现在类体外的函数定义不能指定关键字static；

　　静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；

　　非静态成员函数可以任意地访问静态成员函数和静态数据成员；

　　静态成员函数不能访问非静态成员函数和非静态数据成员；

　　由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；

　　调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：

　　<类名>::<静态成员函数名>（<参数表>）

　　调用类的静态成员函数。

作用

　　static静态变量声明符。在声明它的程序块，子程序块或函数内部有效，值保持，在整个程序期间分配存储器空间，编译器默认值0。

　　是C++中很常用的修饰符，它被用来控制变量的存储方式和可见性。

为什么要引入static

　　函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。

什么时候用static

　　需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。

static的内部机制

　　静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。

　　这样，它的空间分配有三个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数据声明和定义处。

　　静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。

　　static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态

　　数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

static的优势

　　可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

应用格式

　　引用静态数据成员时，采用如下格式：

　　<类名>::<静态成员名>

　　如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。

注意事项

　　(1)类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致了它仅能访问类的静态数据和静态成员函数。

　　(2)不能将静态成员函数定义为虚函数。

　　(3)由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊，变量地址是指向其数据类型的指针，函数地址类型是一个“nonmember 函数指针”。

　　(4)由于静态成员函数没有this指针，所以就差不多等同于nonmember函数，结果就产生了一个意想不到的好处：成为一个callback函数，使得我们得以将C++和C-based X Window系统结合，同时也成功的应用于线程函数身上。

　　(5)static并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问时间，节省了子类的内存空间。

　　(6)静态数据成员在<定义或说明>时前面加关键字static。

　　(7)静态数据成员是静态存储的，所以必须对它进行初始化。

　　(8)静态成员初始化与一般数据成员初始化不同:

　　初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆；

　　初始化时不加该成员的访问权限控制符private，public等；

　　初始化时使用作用域运算符来标明它所属类；

　　所以我们得出静态数据成员初始化的格式：

　　<数据类型><类名>::<静态数据成员名>=<值>

　　(9)为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有重复定义了静态成员，这会不会引起错误呢？不会，我们的编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。在各通信公司的笔试面试中经常出现的考题就是static的作用及功能。

编辑本段C中的static函数

分类

　　static 函数内部函数和外部函数

　　当一个源程序由多个源文件组成时，C语言根据函数能否被其它源文件中的函数调用，将函数分为内部函数和外部函数。

内部函数

　　（又称静态函数）

　　如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数称为内部函数。

　　定义一个内部函数，只需在函数类型前再加一个“static”关键字即可，如下所示：

　　static 函数类型函数名(函数参数表)

　　{……}

　　关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。

　　使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。

外部函数

　　外部函数的定义：在定义函数时，如果没有加关键字“static”，或冠以关键字“extern”，表示此函数是外部函数：

　　[extern] 函数类型函数名(函数参数表)

　　{……}

　　调用外部函数时，需要对其进行说明：

　　[extern] 函数类型函数名(参数类型表)[，函数名2(参数类型表2)……]；

　　[案例]外部函数应用。

　　（1）文件mainf.c

　　main()

　　{ extern void input(…),process(…),output(…);

　　input(…); process(…); output(…);

　　}

　　（2）文件subf1.c

　　……

　　extern void input(……) /*定义外部函数*/

　　{……}

　　（3）文件subf2.c

　　……

　　extern void process(……) /*定义外部函数*/

　　{……}

　　（4）文件subf3.c

　　……

　　extern void output(……) /*定义外部函数*/

　　{……}

数组指针的定义　　数组名的指针，即数组首元素地址的指针。既是指向数组的指针。

　　例：int (*p)[10]; p即为指向数组的指针，又称数组指针。

　　数组指针是指向数组首元素的地址的指针，其本质为指针；

　　指针数组是数组元素为指针的数组(例如 int *p[3],定义了p[0],p[1],p[2]三个指针)，其本质为数组。

最近看到许多朋友一直问数组指针的问题。如果解决了也就没有什么了。遗憾的是帮助解决问题的朋友自己都弄不清楚数组指针到底是怎么回事，甚至会和指针数组，或者一般的基本类型的指针相混淆。为了帮助大家理解这个概念，特发此帖。希望各位高手能够能够说出自己的高见。最后我会把这个帖子整理为faq，以帮助后学者。谢谢大家。
我这里抛砖引玉，先说说自己的看法：

int (*p)[10];
定义了一个数组指针，这个指针与一般的指针没有什么区别，仅仅是这个指针指向一个数组。这里我们把数组作为了基本的元素处理。也就是说，将整个数组作为一种类型，而数组名就是这个类型的一个具体变量。例如：
int a[10];
一个数组类型，形状就是这样：int [10];a就是新定义的一个变量。
int b[3];
一个数组类型，形状就是这样：int [3];b就是新定义的一个变量。
因为这两个类型形状不一样，因此是两个不同的类型，因此a,b就是不同类型的变量。这就好比int a和double b ：a和b不一样。不知道大家是否已经对数组类型有了基本的印象？
那么把数组名作为该数组类型的一个具体变量，我们就可以定义指向这个变量的指针，即数组指针。
对于数组类型：int [10],我们可以定义一个指针，int (*p) [10].注意这里一定要加上小括弧。否则就会变成了指针数组。定义了指针之后，我们可以对该指针赋值，如p=&a;如果定义了一个二维数组，int c[3][10]。我们可以认为定义了一个一维的数组，这个数组有三个int[10]的元素。因此和一般的数组一样，我们可以将该数组名赋给指针，其实也就是第一个元素的地址付给指针。即: p=c;或者p=&c[0]。其余情况以此类推。
好了，就说这么多了。欢迎大家踊跃发言。如果分不够，我会再加的

拆分词条

函数指针

求助编辑百科名片

函数指针是指向函数的指针变量。因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是一致的。函数指针有两个用途：调用函数和做函数的参数。

方法

指针函数和函数指针的区别

关于函数指针数组的定义

为函数指针数组赋值

编辑本段方法

　　函数指针的声明方法为：

　　数据类型 (标志符指针变量名) ( 形参列表);

　　注1：“函数类型”说明函数的返回类型，“(标志符指针变量名 )”中的括号不能省，若省略整体则成为一个函数说明，说明了一个返回的数据类型是指针的函数，后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如：

　　int func(int x); /* 声明一个函数 */

　　int (*f) (int x); /* 声明一个函数指针 */

　　f=func; /* 将func函数的首地址赋给指针f */

　　赋值时函数func不带括号，也不带参数，由于func代表函数的首地址，因此经过赋值以后，指针f就指向函数func(x)的代码的首地址。

　　注2：函数括号中的形参可有可无，视情况而定。

　　下面的程序说明了函数指针调用函数的方法：

　　例一、

　　#include<stdio.h>

　　int max(int x,int y){ return(x>y?x:y); }

　　void main()

　　{

　　int (*ptr)(int, int);

　　int a,b,c;

　　ptr=max;

　　scanf("%d%d",&a,&b);

　　c=(*ptr)(a,b);

　　printf("a=%d,b=%d,max=%d",a,b,c);

　　}

　　ptr是指向函数的指针变量，所以可把函数max()赋给ptr作为ptr的值，即把max()的入口地址赋给ptr,以后就可以用ptr来调用该函数，实际上ptr和max都指向同一个入口地址，不同就是ptr是一个指针变量，不像函数名称那样是死的，它可以指向任何函数，就看你想怎么做了。在程序中把哪个函数的地址赋给它，它就指向哪个函数。而后用指针变量调用它，因此可以先后指向不同的函数。 不过注意，指向函数的指针变量没有++和--运算，用时要小心。

　　不过，在某些编译器中这是不能通过的。这个例子的补充如下。

　　应该是这样的：

　　1.定义函数指针类型：

　　typedef int (*fun_ptr)(int,int);

　　2.申明变量，赋值：

　　fun_ptr max_func=max;

　　也就是说，赋给函数指针的函数应该和函数指针所指的函数原型是一致的。

　　例二、

　　#include<stdio.h>

　　void FileFunc()

　　{

　　printf("FileFunc\n");

　　}

　　void EditFunc()

　　{

　　printf("EditFunc\n");

　　}

　　void main()

　　{

　　typedef void (*funcp)();

　　funcp pfun= FileFunc;

　　pfun();

　　pfun = EditFunc;

　　pfun();　

　　}

编辑本段指针函数和函数指针的区别

　　1,这两个概念都是简称，指针函数是指带指针的函数，即本质是一个函数。我们知道函数都又有返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。

　　其定义格式如下所示：

　　返回类型标识符 *返回名称（形式参数表）

　　{ 函数体 }

　　返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事 实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。例如下面一个返回指针函数的例子：

　　#include<iostream>

　　using namespace std;

　　void main()

　　{

　　float *find(float(*pionter)[4],int n);

　　static float score[][4]={{60,70,80,90},{56,89,34,45},{34,23,56,45}};

　　float *p;

　　int i,m;

　　cout<<"Enter the number to be found:";

　　cin>>m;

　　p=find(score,m);

　　for(i=0;i<4;i++)

　　cout<<" "<<*(p+i);

　　}

　　float *find(float(*pionter)[4],int n)/*定义指针函数*/

　　{

　　float *pt;

　　pt=*(pionter+n);

　　return(pt);

　　}

　　学生学号从0号算起，函数find()被定义为指针函数，起形参pointer是指针指向包含4个元素的一维数组的指针变量。pointer+1指向 score的第一行。*(pointer+1)指向第一行的第0个元素。pt是一个指针变量，它指向浮点型变量。main()函数中调用find()函数，将score数组的首地址传给pointer.

　　2,“函数指针”是指向函数的指针变量，因而“ 函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上一致的。函数指针有两个用途：调用函数和做函数的参数。

编辑本段关于函数指针数组的定义

　　关于函数指针数组的定义方法，有两种：一种是标准的方法；一种是蒙骗法。

　　第一种，标准方法：

　　{

　　分析：函数指针数组是一个其元素是函数指针的数组。那么也就是说，此数据结构是一个数组，且其元素是一个指向函数入口地址的指针。

　　根据分析：首先说明是一个数组：数组名[]

　　其次，要说明其元素的数据类型指针:*数组名[].

　　再次，要明确这每一个数组元素是指向函数入口地址的指针：函数返回值类型 (*数组名[])().请注意，这里为什么要把“*数组名[]”用括号扩起来呢？因为圆括号和数组说明符的优先级是等同的，如果不用圆括号把指针数组说明表达式扩起来，根据圆括号和方括号的结合方向，那么 *数组名[]() 说明的是什么呢？是元素返回值类型为指针的函数数组。有这样的函数数组吗？不知道。所以必须括起来，以保证数组的每一个元素是指针。

　　}

　　第二种，蒙骗法：

　　尽管函数不是变量，但它在内存中仍有其物理地址，该地址能够赋给指针变量。获取函数地址的方法是：用不带有括号和参数的函数名得到。

　　函数名相当于一个指向其函数入口指针常量。那么既然函数名是一个指针常量，那么就可以对其进行一些相应的处理，如强制类型转换。

　　那么我们就可以把这个地址放在一个整形指针数组中，然后作为函数指针调用即可。

　　完整例子：

　　#include "stdio.h"

　　int add1(int a1,int b1);

　　int add2(int a2,int b2);

　　void main()

　　{

　　int numa1=1,numb1=2;

　　int numa2=2,numb2=3;

　　int (*op[2])(int a,int b);

　　op[0]=add1;

　　op[1]=add2;

　　printf("%d %d\n",op[0](numa1,numb1),op[1](numa2,numb2));

　　}

　　int add1(int a1,int b1)

　　{

　　return a1+b1;

　　}

　　int add2(int a2,int b2)

　　{

　　return a2+b2;

　　}

编辑本段为函数指针数组赋值

　　为函数指针数组赋值有两种方式：静态定义和动态赋值。

　　1. 静态定义

　　在定义函数指针数组的时候，已经确定了每个成员所对应的函数。例如：

　　void (*INTARRAY[])(void) = {Stop,Run,Jump};

　　从根本上讲函数指针数组依然是数组，所以和数组的定义类似，由于是静态赋值，[ ]里面的数字可以

　　省略。这个函数指针数组的成员有三个。

　　(*INTARRAY[1])(); //执行Run函数

　　2. 动态赋值

　　也可以先定义一个函数指针数组，在需要的时候为其赋值。为了还原它本来的面目，我们先对这个执行特定类型的函数指针进行类型重定义，然后再用这个新数据类型来定义数组。如下：

　　typedef void (*INTFUN)(void); //此类型的函数指针指向的是无参、无返回值的函数。

　　INTFUN INTARRAY[32]; //定义一个函数指针数组，其每个成员为INTFUN类型的函数指针

　　INTARRAY[10] = INT_TIMER0; //为其赋值

　　(*INTARRAY[10])(); //调用函数指针数组的第10个成员指向的函数

1) #define是预处理指令，在编译预处理时进行简单的替换，不作正确性检查，不关含义是否正确照样带入，只有在编译已被展开的源程序时才会发现可能的错误并报错。例如：
#define PI 3.1415926
程序中的：area=PI*r*r 会替换为3.1415926*r*r
如果你把#define语句中的数字9 写成字母g 预处理也照样带入。

2）typedef是在编译时处理的。它在自己的作用域内给一个已经存在的类型一个别名，但是You cannot use the typedef specifier inside a function definition。

3）typedef int * int_ptr;
与
#define int_ptr int *
作用都是用int_ptr代表 int * ,但是二者不同，正如前面所说，#define在预处理时进行简单的替换，而typedef不是简单替换，而是采用如同定义变量的方法那样来声明一种类型。也就是说;

//refer to (xzgyb(老达摩))
#define int_ptr int *
int_ptr a, b; //相当于int * a, b; 只是简单的宏替换

typedef int* int_ptr;
int_ptr a, b; //a, b 都为指向int的指针,typedef为int* 引入了一个新的助记符

这也说明了为什么下面观点成立
//QunKangLi(维护成本与程序员的创造力的平方成正比)
typedef int * pint ;
#define PINT int *

那么：
const pint p ;//p不可更改，但p指向的内容可更改
const PINT p ;//p可更改，但是p指向的内容不可更改。

pint是一种指针类型 const pint p 就是把指针给锁住了 p不可更改
而const PINT p 是const int * p 锁的是指针p所指的对象。

3）也许您已经注意到#define 不是语句不要在行末加分号，否则会连分号一块置换。

数组中每个元素都具有相同的数据类型，数组元素的类型就是数组的基类型。如果一个数组中的每个元素均为指针类型，即由指针变量构成的数组，这种数组称之为指针数组，它是指针的集合。
指针数组说明的形式为：
类型 * 数组名[常量表达式]
例如： int * pa[5];
表示定义一个由5个指针变量构成的指针数组，数组中的每个数组元素--指针，都指向一个整数，其结构如图10-9所示。

注意"int *pa[5]"与"int (*pb)[5]"的区别。
int (* pb)[5];
表示定义了一个指向数组的指针pb，pb指向的数组是一维的体积为5的整型数组，其结构如图10-10所示。
char * line[5];
表示line是一个5个元素的数组，每个元素是一个指向字符型数据的一个指针。若设指向的字符型数据（字符串）分别是"ONE"、"TWO"、…、"FIVE"，则数组line的结构如图10-11所示。

而：char (*line)[5];
表示line是指向一个长度为５的字符数组的指针。
指针数组常适用于指向若干字符串，这样使字符串处理更加灵活方便。
例10-16：输入字符串，判断该字符串是否是英文的星期几。使用指针数组实现。
#include <stdio.h>
char *week_day[8]= {"sunday", "monday", "tuesday", "wednesday",
"thursday", "friday", "saturday", NULL
}; /* 说明指针数组。数组中的每个元素指向一个字符串 */
main( )
{ int m;
char string[20];
printf("Enter a string: ");
scanf("%s", string);
m=lookup(string);
printf("l=%d/n", m);
}
lookup (ch)
char ch[ ]; /* 传递字符串（字符数组） */
{ int i, j;
char *pc;
for (i=0; week_day[i]!=NULL; i++) /* 完成查找工作 */
{ for( pc=week_day[i],j=0; *pc==ch[j] && *pc!= '/0'; j++,pc++ );
if ( *pc=='/0' )
return(i); /* 若找到则返回对应的序号 */
}
return(-1); /* 若没有找到，则返回-1 */
}

程序中没有使用二维的字符数组，而是采用指针数组week_day。可以看到指针数组比二维字符数组有明显的优点，一是指针数组中每个元素所指的字符串不必限制在相同的字符长度，二是访问指针数组中的一个元素是用指针间接进行的，效率比下标方式要高。
例10-17：输入星期几，输出对应星期的英文名称。用指针数组实现。
#include <stdio.h>
char * week_day[8]= {"sunday", "monday", "tuesday", "wednesday",
"thursday", "friday", "saturday", NULL };
/* 说明指针数组。数组中的每个元素指向一个字符串 */
main( )
{ int day;
char *p, *lookstr( );
printf("Enter day: ");
scanf("%d", &day);
p = lookstr (week_day, day);
printf("%s/n", p);
}
char * lookstr ( table, day ) /* 函数的返回值为指向字符的指针 */
char *table[ ]; /* 传递指向字符串的指针数组 */
int day;
{ int i;
for (i=0; i<day && table[i]!=NULL; i++) ;
if (i==day && table[i]!=NULL)
return ( table[day] );
else return(NULL);
}

例10-18：修改程序10-11，用数组指针作为形参实现函数day_of_year。
#include <stdio.h>
main( )
{ static int day_tab[2][13]={ 0,31,28,31,30,31,30,31,31,30,31,30,31,
0,31,29,31,30,31,30,31,31,30,31,30,31 };
int y, m, d;
scanf ("%d%d%d", &y, &m, &d);
printf("days=%d/n", day_of_year( day_tab, y, m, d ) );
}
day_of_year (day_tab, year, month, day)
int (*day_tab)[13], year, month, day; /* day_tab为数组指针 */
{ int i, j;
i = year%4==0 && year%100!=0 || year%400==0;
for (j=1; j<month; j++)
day += (*(day_tab+i))[j]; /* 引用数组指针指向的数组中的元素 */
return (day);
}

　　请将例C10-11.C和例C10-18.C函数day_of_year进行比较，体会不同类型的形式参数在函数中的使用方法。
事实上，在程序中可以用指针灵活地处理多维数组，使程序优化，并可提高程序的技巧。例如：对于一个三维数组
long a[100][100][100];
要将所有的元素都清0，可采用下面两种方法：
方法一：采用常规的多维数组处理方式方法二：采用指针处理方式
　 long a[100][100][100], i , j, k;　　 long a[100][100][100], i, *pa;
for (i=0; i<100; i++) pa = a;
for (j=0; j<100; j++) for (i=0; i<100*100*100; i++)
for (k=0; k<100; k++) *pa++ = 0;
a[i][j][k]=0;
方法一直接使用三维数组中的数组元素，访问其中的任一数组元素a[i][j][k]时，每次都要调用数组元素地址的计算公式。而方法二则利用三维数组在内存中是按行线性顺序存放的这一特性，通过一个指针顺序加1的方法实现对数组a中所有元素的赋0操作。两种处理方法相比较，方法二处理速度比方法一快得多。

推荐一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

　　1). 并行设备的硬件寄存器（如：状态寄存器）

　　2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

　　3). 多线程应用中被几个任务共享的变量

　　回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。

　　假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是真正懂得volatile完全的重要性。

　　1). 一个参数既可以是const还可以是volatile吗？解释为什么。

　　2). 一个指针可以是volatile 吗？解释为什么。

　　3). 下面的函数有什么错误：

　　int square(volatile int *ptr)

　　{

　　return *ptr * *ptr;

　　}

　　下面是答案：

　　1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

　　2). 是的。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。

　　3). 这段代码是个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

　　int square(volatile int *ptr)

　　{

　　int a,b;

　　a = *ptr;

　　b = *ptr;

　　return a * b;

　　}

　　由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

　　long square(volatile int *ptr)

　　{

　　int a;

　　a = *ptr;

　　return a * a;

　　}

　　讲讲我的理解：（欢迎打板子...~~！）

　　关键在于两个地方：

　　1. 编译器的优化 (请高手帮我看看下面的理解)

　　在本次线程内, 当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后，再取变量值时，就直接从寄存器中取值；

　　当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致

　　当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致

　　当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致

　　举一个不太准确的例子：

　　发薪资时，会计每次都把员工叫来登记他们的银行卡号；一次会计为了省事，没有即时登记，用了以前登记的银行卡号；刚好一个员工的银行卡丢了，已挂失该银行卡号；从而造成该员工领不到工资

　　员工－－原始变量地址

　　银行卡号－－原始变量在寄存器的备份

　　2. 在什么情况下会出现(如1楼所说)

　　1). 并行设备的硬件寄存器（如：状态寄存器）

　　2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

　　3). 多线程应用中被几个任务共享的变量

　　补充： volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人；

　　“易变”是因为外在因素引起的，象多线程，中断等，并不是因为用volatile修饰了的变量就是“易变”了，假如没有外因，即使用volatile定义，它也不会变化；

　　而用volatile定义之后，其实这个变量就不会因外因而变化了，可以放心使用了；大家看看前面那种解释（易变的）是不是在误导人

　　－－－－－－－－－－－－简明示例如下：－－－－－－－－－－－－－－－－－－

　　volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

　　使用该关键字的例子如下：

　　int volatile nVint;

　　>>>>当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

　　例如：

　　volatile int i=10;

　　int a = i;

　　...

　　//其他代码，并未明确告诉编译器，对i进行过操作

　　int b = i;

　　>>>>volatile 指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。

　　>>>>注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：

　　>>>>首先，用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码：

　　#i nclude <stdio.h>

　　void main()

　　{

　　int i=10;

　　int a = i;

　　printf("i= %d",a);

　　//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道

　　__asm {

　　mov dword ptr [ebp-4], 20h

　　}