2010.3.26

1】C语言的逻辑运算符：

     && 逻辑与，|| 逻辑或 ；如 表达式1&&x<表达式2，如果表达式1为假，则表达式2不会执行；因此在对于会改变变量的表达式中，要注意&&的判断运行规则。

2】数组：

     总字节数 = sizeof(数据类型)*元素个数

     const int days[] = {31,28,31,30,31,30};

     int index;

     for(intdex=0;index<sizeof days/sizeof days[0];index++)

          printf("Month %2d has %d days/n",index+1,days[index]);

3】多维数组：

     对于多维数组的分析因采用分解的思想。

4】指针：

     px + n       指针向地址大的方向移动n个数据

     n 有多大？取决于px所指向的类型

     px+n表示的实际位置的地址量是：（px）+sizeof（px的类型）*n

5】对于一个数组S[n]，&s+1表示什么意思？s+1表示什么意思？

     &s+1等价于一个数组指针  int *[]     即&s代表的还是一个地址与s的值是相同的，只不过它所表示的类型变了。

     s+1等价一个指针    int *                    s代表

错6】对一个数组赋初值，常量(define x 10) char s[x]=“abcd”;可行？变量 int x=1;char s[x]="abcd";非法的？

     这里就涉及到了一个预处理和编译类型的问题，跟我们的编译流程有关。define x 10 在预处理之前定义是常量；int x=1 在预处理之

     后程序运行时加载的，而char s[x]="abcd" 初始化是在预处理的时候进行的，也就是说，当编译器预处理的时候，要给s[x]指定分配

     一份内存，而x的值还没有指定，是一个随即值，因此会产生错误。

7】赋初值与预处理的关系？

     比如 int i=10;   将数据10放在一个rodata段里，当程序加载到vm运行的时候，取出10给i; 

            int i;i=10;

8】指针变量与数组的指针（或叫数组名）存在本质的不同，指针变量是地址变量，而数组的指针（数组名）是地址常量。

9】初学者经常犯的一个毛病！！！

     char *p;

     strcpy(p,"Hello");       p必须先指向一段合法内存。

     解决方法：p=malloc(10) (动态分配);或p=a[10];

10】int **pp;int *p;则**（pp+1）与 *(p+1)有什么不同？

11】字符指针与字符串

      在程序中，初始化字符指针是把内存中字符串的首地址赋予指针，另外当一个字符指针初始化为指向一个字符串常量时，不能对字符指

      针变量的目标赋值。

      如：

          1>char *ps="hello";        "hello"是字符串常量，表示只读字符串。

          2>char str[]="hello";       将hello初始化到str[]中来，str[]是可变的。

          因此，*ps='x'; 对于1>来说是错误的。对于2>来说是对的，等价与str[0]='x';

12】const 在c与c++中区别？

       c 中 const定义一个只读变量；

       c++ 中 const定义一个常量（可以用const替代define）；

       在看下面的一些定义：

       const int *p;           p所指向的目标不可变，不能通过*p去修改p所指向的变量，变量本身是可以修改的；如：*p=4错；x=4对；

                                      我们可以这样来理解，const修饰int，而下面的const修饰p。int const *p等同于const int *p

       int *const p;           指针本身不可变，只读的；因此在定义他的时候要对它初始化，否则以后不可变了。

       对于const，给我们带来了一定安全性的作用；比如：

                                                                             func(const char *s)

                                                                      保证了函数内部不会通过*s改变s所指向的值。

13】函数的参数传递：

           函数与函数之间的数组传递，复制传递方式只是提供一种形式，被调用函数的形参数组的数组名实际上是一个指针变量，因此，复制

      传递方式与数组的指针传递方式完全相同，只是形参的说明形式不同而已。

       看下面一个例子：

                             void func(char str[])

                             {

                                    printf("%d/r/n",sizeof(str));

                             }

                              int main()

                              {

                                    char str[]="abcdefg";

                                    printf("%d/r/n",sizeof(str));

                                    func(str);

                              }

                     打印的结果是：    8

                                              4

        这就证实了函数参数传递的是一个指针，即使是数组，编译器也会将它当成指针。

        下面看下指针与数组的一些对比：

                                指针                                         数组

                           存放地址                                  存放数据

                           指向匿名内存                             数组名

                           间接访问                                   直接访问

                           malloc动态内存                         自动存储

                           地址变量                                   地址常量

14】数组下标是否可以为-1？

       答案是肯定的；这里我们要理清一个思路，数组的下标仅表示偏移量，设数组 double a[i];我们可以通过a[i]取得这个数组中的某个值，其实制是通过*(a+i)取得，因此如果在定义一个函数:   通过func(a)传递参数

                                                       func(double b[])

                                                      {

                                                              b++;            此时b指向的是a+1这个地址，即a[1]的值

                                                              b[-1];           此时b[-1]相当与*(b-1)，即a[0]的值

                                                       }

15】指针数组与数组指针

        一个数组，若其元素均为指针类型数据，称为指针数组，也就是说，指针数组中每一个元素都相当于一个指针变量。

16】指针函数与函数指针

       函数指针是用来存放函数的地址，这个地址是一个函数的入口地址，而且是函数调用时使用的起始地址。

       如：

           int func(double)                  int (*pf) (double);

           {                                         pf=func;

                                                      pf(double);          此时调用pf就相当与在调用func

           }