【C++ Primer】摘记--第4章 数组和指针

第四章 数组和指针

1. C++ 语言提供了两种类似于 vector 和迭代器类型的低级复合类型——数组和指针。与 vector 类型相似，数组也可以保存某种类型的一组对象；而它们的区别在于，数组的长度是固定的。数组一经创建，就不允许添加新的元素。指针则可以像迭代器一样用于遍历和检查数组中的元素。

2. 现代 C++ 程序应尽量使用 vector 和迭代器类型，而避免使用低级的数组和指针。设计良好的程序只有在强调速度时才在类实现的内部使用数组和指针。

 

3. 与 vector 类型相比，数组的显著缺陷在于：数组的长度是固定的，而且程序员无法知道一个给定数组的长度。数组没有获取其容量大小的 size 操作，也不提供 push_back 操作在其中自动添加元素。如果需要更改数组的长度，程序员只能创建一个更大的新数组，然后把原数组的所有元素复制到新数组空间中去。

4. 数组定义中的类型名可以是内置数据类型或类类型；除引用之外，数组元素的类型还可以是任意的复合类型。没有所有元素都是引用的数组。

5. 数组的维数必须用值大于等于1的常量表达式定义（第 2.7 节）。此常量表达式只能包含整型字面值常量、枚举常量（第 2.7 节）或者用常量表达式初始化的整型 const 对象。非 const 变量以及要到运行阶段才知道其值的 const 变量都不能用于定义数组的维数。

 

6. 如果指定了数组维数，那么初始化列表提供的元素个数不能超过维数值。如果维数大于列出的元素初值个数，则只初始化前面的数组元素；剩下的其他元素，若是内置类型则初始化为0，若是类类型则调用该类的默认构造函数进行初始化。

 

7. 如果必须在数组中添加新元素，程序员就必须自己管理内存：要求系统重新分配一个新的内存空间用于存放更大的数组，然后把原数组的所有元素复制到新分配的内存空间中。

4.2. Introducing Pointers

8．语句 string* ps1, ps2;只把 ps1 定义为指针，而 ps2 并非指针，只是一个普通的 string 对象而已。如果需要在一个声明语句中定义两个指针，必须在每个变量标识符前再加符号 * 声明：  string* ps1, *ps2; // both ps1 and ps2 are pointers to string

9. 若指针保存0值，表明它不指向任何对象。未初始化的指针是无效的，直到给该指针赋值后，才可使用它。很多运行时错误都源于使用了未初始化的指针。

10. 如果可能的话，除非所指向的对象已经存在，否则不要先定义指针，这样可避免定义一个未初始化的指针。如果必须分开定义指针和其所指向的对象，则将指针初始化为 0。因为编译器可检测出 0 值的指针，程序可判断该指针并未指向一个对象。

11. 对指针进行初始化或赋值只能使用以下四种类型的值：

1) 0 值常量表达式（第 2.7 节），例如，在编译时可获得 0 值的整型 const 对象或字面值常量 0。

2)类型匹配的对象的地址。

3)另一对象末的下一地址。

4)同类型的另一个有效指针。指针只能初始化或赋值为同类型的变量地址或另一指针：    double dval;

          double *pd = &dval;   // ok: initializer is address of a double
       
       

          double *pd2 = pd;     // ok: initializer is a pointer to double
       
       

          int *pi = pd;   // error: types of pi and pd differ
       
       

          pi = &dval;     // error: attempt to assign address of a double to int *
       
       

把 int 型变量赋给指针是非法的，尽管此 int 型变量的值可能为 0。但允许把数值 0 或在编译时可获得 0 值的 const 量赋给指针.

12. 由于指针的类型用于确定指针所指对象的类型，因此初始化或赋值时必须保证类型匹配。指针用于间接访问对象，并基于指针的类型提供可执行的操作，例如，int 型指针只能把其指向的对象当作 int 型数据来处理，如果该指针确实指向了其他类型（如 double 类型）的对象，则在指针上执行的任何操作都有可能出错。

13．C++ 提供了一种特殊的指针类型 void*，它可以保存任何类型对象的地址。void* 表明该指针与一地址值相关，但不清楚存储在此地址上的对象的类型。void* 指针只支持几种有限的操作：与另一个指针进行比较；向函数传递 void* 指针或从函数返回 void* 指针；给另一个 void* 指针赋值。不允许使用 void* 指针操纵它所指向的对象。我们将在第 5.12.4 节讨论如何重新获取存储在 void* 指针中的地址。

指针和引用的比较

14．第一个区别在于引用总是指向某个对象：定义引用时没有初始化是错误的。第二个重要区别则是赋值行为的差异：给引用赋值修改的是该引用所关联的对象的值，而并不是使引用与另一个对象关联。引用一经初始化，就始终指向同一个特定对象（这就是为什么引用必须在定义时初始化的原因）。

15．考虑以下两个程序段。第一个程序段将一个指针赋给另一指针：

          int ival = 1024, ival2 = 2048;
       
       

          int *pi = &ival, *pi2 = &ival2;
       
       

          pi = pi2;    // pi now points to ival2
       
       

赋值结束后，pi 所指向的 ival 对象值保持不变，赋值操作修改了 pi 指针的值，使其指向另一个不同的对象。现在考虑另一段相似的程序，使用两个引用赋值：

          int &ri = ival, &ri2 = ival2;
       
       

          ri = ri2;    // assigns ival2 to ival
       
       

这个赋值操作修改了 ri 引用的值 ival 对象，而并非引用本身。赋值后，这两个引用还是分别指向原来关联的对象，此时这两个对象的值相等。

 

16. C++ 语言中，指针和数组密切相关。特别是在表达式中使用数组名时，该名字会自动转换为指向数组第一个元素的指针：

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

          int *ip = ia; // ip points to ia[0]
       
       

17. 指针的算术操作只有在原指针和计算出来的新指针都指向同一个数组的元素，或指向该数组存储空间的下一单元时才是合法的。如果指针指向一对象，我们还可以在指针上加1从而获取指向相邻的下一个对象的指针。假设数组 ia 只有 4 个元素，则在 ia 上加 10 是错误的

 

18. 使用下标访问数组时，实际上是使用下标访问指针。
        
        

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

int i = ia[0]; // ia points to the first element in ia
       
       

ia[0] 是一个使用数组名的表达式。在使用下标访问数组时，实际上是对指向数组元素的指针做下标操作。只要指针指向数组元素，就可以对它进行下标操作

19. C++ 允许计算数组或对象的超出末端的地址，但不允许对此地址进行解引用操作。而计算数组超出末端位置之后或数组首地址之前的地址都是不合法的。

指针和 const 限定符：指向 const 对象的指针和 const 指针

 

20. 指向 const 对象的指针（也可指向非const的对象）：C++ 语言强制要求指向 const 对象的指针也必须具有 const 特性：

          const double *cptr;  // cptr may point to a double that is const
       
       

这里的 cptr 是一个指向 double 类型 const 对象的指针，const 限定了 cptr 指针所指向的对象类型，而并非 cptr 本身。也就是说，cptr 本身并不是 const。在定义时不需要对它进行初始化，如果需要的话，允许给 cptr 重新赋值，使其指向另一个 const 对象。但不能通过 cptr 修改其所指对象的值：

          *cptr = 42;   // error: *cptr might be const
       
       

允许把非 const 对象的地址赋给指向 const 对象的指针，例如：

          double dval = 3.14; // dval is a double; its value can be changed
       
       

          cptr = &dval;       // ok: but can't change dval through cptr
       
       

不能使用指向 const 对象的指针修改基础对象，然而如果该指针指向的是一个非 const 对象，可用其他方法修改其所指的对象。

如果指向 const 的指针所指的对象并非 const，则可直接给该对象赋值或间接地利用普通的非 const 指针修改其值：毕竟这个值不是 const。重要的是要记住：不能保证指向 const 的指针所指对象的值一定不可修改。

 

21. const 指针：C++ 语言还提供了 const 指针——本身的值不能修改：

          int errNumb = 0;
       
       

          int *const curErr = &errNumb; // curErr is a constant pointer
       
       

与其他 const 量一样，const 指针的值不能修改，这就意味着不能使 curErr 指向其他对象。与任何 const 量一样，const 指针也必须在定义时初始化。指针本身是 const 的事实并没有说明是否能使用该指针修改它所指向对象的值。指针所指对象的值能否修改完全取决于该对象的类型。例如，curErr 指向一个普通的非常量 int 型对象 errNumb，则可使用 curErr 修改该对象的值。

 

22. const 限定符既可以放在类型前也可以放在类型后：

          string const s1;   // s1 and s2 have same type,
       
       

          const string s2;   // they're both strings that are const
        
        

typedef string *pstring;
       
       

          const pstring cstr;
       
       

该声明语句应该是把 cstr 定义为指向 string 类型对象的 const 指针，这个定义等价于：

          // cstr is a const pointer to string
       
       

          string *const cstr; // equivalent to const pstring cstr
       
       

   ----》     
        
        

  string s;
       
       

          typedef string *pstring;
       
       

          const pstring cstr1 = &s; // written this way the type
        
        

    
    
    
    

     
      
      
      
 
     
     

      
        
       
       
  
       
       
  
       
       
  
       
       
  
       
       
  
       
       
  
       
       
  
       
       
  
       
       
  
       
       
  
       
       
  
       
       
 
     
     

     
      
      
      
 
      
      

    
    
    
    

     
      
      
      
      
      

    
     is obscured
       
       

          pstring const cstr2 = &s; // all three decreations are
        
        

    
    

     
      
       
       

    
     the same type
       
       

          string *const cstr3 = &s; // they're all const pointers
        
        

    
    

     
      
       
       

    
     to string
       
       

 

4.3. C 风格字符串

表 4.1. 操纵 C 风格字符串的标准库函数

strlen(s)	返回 s 的长度，不包括字符串结束符 null
strcmp(s1, s2)	比较两个字符串 s1 和 s2 是否相同。若 s1 与 s2 相等，返回 0；若 s1 大于 s2，返回正数；若 s1 小于 s2，则返回负数
strcat(s1, s2)	将字符串 s2 连接到 s1 后，并返回 s1
strcpy(s1, s2)	将 s2 复制给 s1，并返回 s1
strncat(s1, s2,n)	将 s2 的前 n 个字符连接到 s1 后面，并返回 s1
strncpy(s1, s2, n)	将 s2 的前 n 个字符复制给 s1，并返回 s1

 

23. 在使用处理 C 风格字符串的标准库函数时，牢记字符串必须以结束符 null 结束：

          char ca[] = {'C', '+', '+'}; // not null-terminated
       
       

          cout << strlen(ca) << endl; // disaster: ca isn't null-terminated
       
       

 

24. 数组类型的变量有三个重要的限制：数组长度固定不变，在编译时必须知道其长度，数组只在定义它的块语句内存在。实际的程序往往不能忍受这样的限制——它们需要在运行时动态地分配数组。虽然数组长度是固定的，但动态分配的数组不必在编译时知道其长度，可以（通常也是）在运行时才确定数组长度。与数组变量不同，动态分配的数组将一直存在，直到程序显式释放它为止。

 

25. 数组变量通过指定类型、数组名和维数来定义。而动态分配数组时，只需指定类型和数组长度，不必为数组对象命名，new 表达式返回指向新分配数组的第一个元素的指针：

          int *pia = new int[10]; // array of 10 uninitialized ints
       
       

在自由存储区中创建的数组对象是没有名字的，程序员只能通过其地址间接地访问堆中的对象。

 

26. 动态分配数组时，如果数组元素具有类类型，将使用该类的默认构造函数（第 2.3.4 节）实现初始化；如果数组元素是内置类型，则无初始化：

          string *psa = new string[10]; // array of 10 empty strings
       
       

          int *pia = new int[10];       // array of 10 uninitialized ints
       
       

也可使用跟在数组长度后面的一对空圆括号，对数组元素做值初始化（第 3.3.1 节）：

          int *pia2 = new int[10] (); 
       
       

圆括号要求编译器对数组做值初始化，在本例中即把数组元素都设置为0。对于动态分配的数组，其元素只能初始化为元素类型的默认值，而不能像数组变量一样，用初始化列表为数组元素提供各不相同的初值。

 

27. const 对象的动态数组

如果我们在自由存储区中创建的数组存储了内置类型的 const 对象，则必须为这个数组提供初始化：因为数组元素都是 const 对象，无法赋值。实现这个要求的唯一方法是对数组做值初始化：

          // error: uninitialized const array
       
       

          const int *pci_bad = new const int[100];
       
       

          // ok: value-initialized const array
       
       

          const int *pci_ok = new const int[100]();
       
       

C++ 允许定义类类型的 const 数组，但该类类型必须提供默认构造函数：

          // ok: array of 100 empty strings
       
       

          const string *pcs = new const string[100];
       
       

在这里，将使用 string 类的默认构造函数初始化数组元素。当然，已创建的常量元素不允许修改——因此这样的数组实际上用处不大。

28. C++ 虽然不允许定义长度为 0 的数组变量，但明确指出，调用 new 动态创建长度为 0 的数组是合法的：

          char arr[0];            // error: cannot define zero-length array
       
       

          char *cp = new char[0]; // ok: but cp can't be dereferenced
        
        

29. C++ 语言为指针提供 delete [] 表达式释放指针所指向的数组空间：

          delete [] pia;
       
       

在关键字 delete 和指针之间的空方括号对是必不可少的：它告诉编译器该指针指向的是自由存储区中的数组，而并非单个对象。

 

30. （待续）