C/C++复习之路——王道程序员求职宝典——第一章

古城微笑少年丶 2023-02-28 12:56 37阅读 0赞

### 文章目录 ###

*   *  动态声明一维数组
     *  C风格字符串与字符数组
     *  二维数组
     *  行优先存储和列优先存储
     *  动态数组
     *   *  一维动态数组
         *  二位动态数组
     *  指针数组和数组指针
     *  char数组

## 动态声明一维数组 ##

当数组大小未知时，需要动态声明一维数组，声明格式如下：

int* a = new int[n];

使用完毕是需要释放空间

delete []a;

## C风格字符串与字符数组 ##

1.  **字符常量**`'A'`
2.  **字符串常量**`"A"`，编译器会自动在末尾添加一个**空字符**，其表示字母A和空字符(null)两个字符。
3.  末尾加了`\0`的字**符数组**。

Eg1. 下列\_\_\_是不正确的字符常量？

*  A. ‘n’
 *  B. ‘I’
 *  C. “a”
 *  D. ‘\\101’  
    解析：答案选C，C选项是一个字符串常量，其包含字符’a’和空字符两个字符。

Eg2.下列哪些是C风格字符串？

*  A. char ca1\[\]=\{‘C’, ‘+’, ‘+’\};
 *  B. char ca2\[\]=\{‘C’, ‘+’, ‘+’, ‘\\0’\};
 *  C. char ca3\[\]=“C++”;
 *  D. const char \*cp = “C++”;
 *  E. char \*cp1 = ca1;
 *  F. char \*cp2 = ca2;  
    解析：A、E不是：ca1是一个不带结束符null的字符数组，而指针cp1指向ca1的首字符，因此，它指向的并不是以null结束的数组。其他的声明都是C风格字符串。

**字符数组**  
  字符数组可以用一组花括号括起来、逗号隔开的字符常量进行初始化,也可以使用一个常量字符串（末尾有空字符）进行初始化，如下：

char ca1[]={ 'C', '+', '+'}; //末尾没有null字符，长度为3，不是C风格字符串
    char ca2[]={ 'C', '+', '+', '\0'};// 末尾显式的添加null字符，长度为4，其为C风格字符串
    char ca3[]="C++";//末尾自动添加null字符，长度为4，其为C风格字符串

## 二维数组 ##

1.  按行初始化

int ia[3][4] = { 
        { 0,1,2,3},
        { 4,5,6,7},
        { 8,9,10,11}
    };

1.  顺序初始化

int ia[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11};

1.  只初始化每一行第一个元素

int ia[3][4] = { { 0},{ 4},{ 8}};

1.  只初始化第一行元素

int ia[3][4] = { 0,3,6,9};

1.  行数省略，切记列不可以省略

int ia[][4] = { 1,2,3,4,5,6};

Eg1. 下面代码的输出结果为？

int main(){ 
        int a[3][2] = { (0,1), (2,3), (4,5)};//语句1
        int* p=a[0];
        printf("%d", p[0]);
    }

解析：结果为1。此处涉及到都好运算符的作用。简单介绍下，其作用如下：

*  使用逗号运算符是为了把几个表达式放在一起。
 *  整个逗号表达式的值为系列中最后一个表达式的值。
 *  从本质上讲，逗号的作用是将一系列运算按顺序执行。  
    例如对于：`var = (count=19, incr=10, count+1);`  
    在这里，首先把 count 赋值为 19，把 incr 赋值为 10，然后把 count 加 1，最后，把最右边表达式 count+1 的计算结果 20 赋给 var。上面表达式中的括号是必需的，因为逗号运算符的优先级低于赋值操作符。

所以原题目中的语句1相当于：

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

Eg2.

int b=2, v=7, d=5;
    int a1, a2;
    a1 = (++b, c--, d+3); //语句1
    a2=++b, c--, d+3; //语句2

解析：对于语句1，有三个表达式，用逗号分开，所以最终的值应该是最后一个表达式里面的值，也就是d+3，为8，所以a1=8。  
对于语句2，那么也是有三个表达式，这时三个表达式为a2=++b，c–，d+3,（这时因为赋值运算符比逗号运算法优先级高）。所以最终表达式的值虽然也是为8，但是a2=4。

## 行优先存储和列优先存储 ##

在C、C++中，二维数组按照行优先顺序连续存储。  
Eg1.

#define M 3
    #define N 4
    int get(int *p, int i, int j){ 
        if (NULL==p || i<0 || i>M || j<0 || j>N) return 0;
        return ______;
    }
    int main(){ 
        int a[M][N] = { { 1,2,3,4},{ 5,6,7,8},{ 9,10,11,12}};
        printf("a[2][3]==%d\n",get(&a[0][0],2,3));
        return 0;
    }

解析：答案是：*(p+i*N+j)。函数get传入参数是一个指针，存储时按照行优先存储，因此p+i*N+j便可以让p指向a\[2\]\[3\]，再使用*()获取指向地址存储的数据。

## 动态数组 ##

在C、C++中创建数组时必须要确定数组的大小，虽然对于二维数组的行可以省略，但是仍然不能随心所欲的创建任意大小的数组。因此可以使用动态数组

### 一维动态数组 ###

int *a = new int [m]

使用完需要删除：

delete a

### 二位动态数组 ###

int **a = new int* [m]
    for (int i=0;i<m; i++)
        a[i] = new int [n];

使用时直接调用a\[i\]\[j\]或者\*(\*(a+i)+j)。

## 指针数组和数组指针 ##

指针数组是数组，数组指针是指针，在使用的时候看后面两个字即可。

*  指针数组值的是一个数组里面装的是指针。
    
        int *a[10];
 *  数组指针指的是指向数组的指针。
    
        int a[10];
        int *(p)[10] = &a;
        p = a; //a是类型是int(*) [10]。

Eg1. 对于下面的例子：

int a[10];
    int (*p)[10] = &a;
    int *q = a;

解析：虽然p与q都是指向数组的一个元素，但是p的类型与q的不同，p是指向有10个元素类型数组的指针，\*p的大小是40个字节，故p+1跳过40个字节。  
  而q是指向整型的指针，\*p的大小是4个字节，故p+1跳过4个字节。

Eg2. 设有"int w\[3\]\[4\];"，pw是指向与数组名w等阶的数组指针，则pw的初始化语句为\_\_\_\_\_\_。  
解析：int \*(pw)=w;

int a[] = { }0,2,4,6,8};
    int *ip = a;  //指针指向数组首字母
    int *ip;
    ip = &a[4];  //指针指向a的最后一个元素8
    printf("%d\n", a); //输出数组a的第一个元素的地址

修改第四个元素为9：a\[4\]=9; 或\*(a+4)=9; 或 ip\[4\] = 9; 或 \*(ip+4)=9;

<table> 
 <thead> 
  <tr> 
   <th align="left">表达式</th> 
   <th align="left">假定p是指向…的指针</th> 
   <th align="left">二*p的大小是</th> 
   <th align="left">增加到的指针的值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">p+1</td> 
   <td align="left">char</td> 
   <td align="left">1</td> 
   <td align="left">1</td> 
  </tr> 
  <tr> 
   <td align="left">p+1</td> 
   <td align="left">short</td> 
   <td align="left">2</td> 
   <td align="left">2</td> 
  </tr> 
  <tr> 
   <td align="left">p+1</td> 
   <td align="left">int</td> 
   <td align="left">4</td> 
   <td align="left">3</td> 
  </tr> 
  <tr> 
   <td align="left">p+1</td> 
   <td align="left">double</td> 
   <td align="left">8</td> 
   <td align="left">8</td> 
  </tr> 
 </tbody> 
</table>

Eg. 针对int a\[10\];以下表达式不可以表示a\[1\]的地址的是\_\_\_\_\_？

*  A. a+sizeof(int)
 *  B. &a\[0\]+1
 *  C. (int\*)&a+1
 *  D. (int\*)((char\*)&a+sizeof(int))

解析：答案选A。

A中sizeof(int)为4，a是指向数组首元素的指针，指向的元素类型为int，每加1就会自动跳过4个字节。因此这里加4就会跳过4x4=16个字节；

B中&a\[0\]为首元素的地址，股也是指向首元素的指针，即&a\[0\]等价于a；&a为指向数组的指针，与a的类型不同（&a为int(\*)\[10\]），但是指向的单元相同；正确

C中，将&a强制转换成int\*类型，则执行+1跳过一个int大小（4个字节），指向a\[1\]，正确

D中将&a转换为char*类型，则+1跳过一个char大小（1），故指向a\[1\]的首字节需要+4，然后转换为int*类型（指向a\[1\]的指针类型为int\*）;正确

下面的图很重要！！！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2Nzc1Mjkz_size_16_color_FFFFFF_t_70]

*  a：类型为int(\*)\[3\]，即a为指向数组a第0个元素a\[0\]的指针，且a为常量，不能进行赋值运算（不可修改的左值）。a+i的类型也同为int(\*)\[3\]，指向a\[i\]；
 *  \*a或a\[0\]类型为int\*，\*a为指向数组a\[0\]首元素a\[0\]\[0\]的指针；
 *  \*(a+1)或a\[1\]类型为int\*，因s的类型为int(\*)\[3\]，即a指向一个有3个元素的一维数组，故a+1跳过3个元素。则(a+1)为指向数组a的第一个元素a\[1\]的指针，即\*(a+1)或a\[1\]为指向数组a\[1\]首元素a\[1\]\[0\]的指针；
 *  \*(\*(a+1)+2))类型为int，因为\*(a+1)类型为int\*，故(\*(a+1)+2)将跳过2个int元素。则(\*(a+1)+2)为指向数组a\[1\]第二个元素a\[1\]\[2\]的指针，即\*(\*(a+1)+2))为数组a\[1\]的第2个元素a\[1\]\[2\]。  
    可以使用下面程序验证：

int a[3][2] = { 1,2,3,4,5,6};
        printf("%c\n", p[1]);
        printf("%d\n", a);
        printf("%d\n", &a);
        printf("%d\n", &a+1);

其中\*a\[0\]=0。\*(a\[1\]+1))=6，其中a\[1\]指向第二行首个元素，+1往后移一位，也可以使用\*(&a\[0\]\[0\]+5)表示。

Eg. 写出下程序片段的输出结果

int a[] = { 1,2,3,4,5};
    int *ptr = (int*)(&a+1);
    printf("%d", *(ptr-1));

解析：答案是5。&a+1不是a+1，&a+1的类型为(int\*)(5)，故&a+1使得指针跳过整个数组a的大小。所以ptr-1指向a的最后一个元素，即为5。

## char数组 ##

char str[2] ={ 'a', 'b'};
    char str[2][3] = { "a", "b"}; //等价于 char str[2][3] = { {"a"}, {"b"}};

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2Nzc1Mjkz_size_16_color_FFFFFF_t_70]: /images/20230209/df97239d02a648b78510de53f9823e19.png