［primer］chapter4--array and pointer

C++ 语言提供了两种类似于 vector 和迭代器类型的低级复合类型——数组和指针（二者为内置数据类型）。应尽量使用vector和iterator

2.数组的维数必须用值大于等于1的常量表达式定义。此常量表达式只能包含整型字面值常量、枚举常量或者用常量表达式初始化的整型 const 对象。非 const 变量以及要到运行阶段才知道其值的 const 变量都不能用于定义数组的维数。所以运行时才知道维数的情况是不也以定义数组的，这时使用vector

// both buf_size and max_files are const const unsigned buf_size = 512, max_files = 20; int staff_size = 27; // nonconst const unsigned sz = get_size(); // const value not known until run time char input_buffer[buf_size]; // ok: const variable string fileTable[max_files + 1]; // ok: constant expression double salaries[staff_size]; // error: non const variable int test_scores[get_size()]; // error: non const expression int vals[sz]; // error: size not known until run time
3.显式初始化的数组不需要指定数组的维数值，编译器会根据列出的元素个数来确定数组的长度

4.字符数组
           char ca1[] = {'C', '+', '+'}; // no null char ca2[] = {'C', '+', '+', '/0'}; // explicit null char ca3[] = "C++"; // null terminator added automatically

 

 

5.数组不允许直接复制和赋值。所以数组不能像vector那样直接初始化。对数据类型，首先就要考虑如何对其进行初始化。然后考虑作用在其上的操作。string和vector支持复制和赋值，同时也支持关系操作符！ ！！！注意：string和vector的关系操作符均遵循下列规则：根据第一个不匹配的元素来比较！null小！

vector 的遍历可使用下标或迭代器实现，同理，也可用下标或指针来遍历数组。指针是指向某种类型对象的复合数据类型，是用于数组的迭代器：指向数组中的一个元素。在指向数组元素的指针上使用解引用操作符 *（dereference operator）和自增操作符 ++（increment operator），与在迭代器上的用法类似。

 

指针

 

指针的概念很简单：指针用于指向对象。与迭代器一样，指针提供对其所指对象的间接访问，只是指针结构更通用一些。与迭代器不同的是，指针用于指向单个对象，而迭代器只能用于访问容器内的元素。具体来说，指针保存的是另一个对象的地址
指针和数组容易产生不可预料的错误。其中一部分是概念上的问题：指针用于低级操作，容易产生与繁琐细节相关的（bookkeeping）错误。其他错误则源于使用指针的语法规则，特别是声明指针的语法。

指针可以进行赋值（0或NULL或其他指针；允许把数值 0 或在编译时可获得 0 值的 const 量赋给指针。关键是要使指针获得有效地址。0指只是告诉编译器指针未初始化；NULL是从c继承下来的预处理器变量，其值为0，预处理时会将NULL替换为0）
由于指针的类型用于确定指针所指对象的类型，因此初始化或赋值时必须保证类型匹配。

避免未初始化的指针！对大多数的编译器来说，如果使用未初始化的指针，会将指针中存放的不确定值视为地址通常会导致程序崩溃。C++ 语言无法检测指针是否未被初始化，也无法区分有效地址和由指针分配到的存储空间中存放的二进制位形成的地址

void* 指针可以保存任何类型对象的地址，表明该指针与一地址值相关，但不清楚存储在此地址上的对象的类型。
void* 指针只支持几种有限的操作：与另一个指针进行比较；向函数传递 void* 指针或从函数返回 void* 指针；给另一个 void* 指针赋值。不允许使用 void* 指针操纵它所指向的对象。

指针操作 ：
1.dereference(*）
2.对指针赋值就是修改指针指向的对象，而使用解引用指针作为左操作数进行赋值则修改的是指针指向对象的值。给引用赋值修改的是该引用所关联的对象的值，而并不是使引用与另一个对象关联。引用一经初始化，就始终指向同一个特定对象（这就是为什么引用必须在定义时初始化的原因）。
3.指针可以进行算术操作。在指针上加一个整型数值，其结果仍然是指针。允许在这个结果上直接进行解引用操作，而不必先把它赋给一个新指针。两个指针可以进行减操作，以后得到ptrdiff_t类型的二者差几个对象

C++ 语言中，指针和数组密切相关。特别是在表达式中使用数组名时，该名字会自动转换为指向数组第一个元素的指针。在使用下标访问数组时，实际上是对指向数组元素的指针做下标操作。只要指针指向数组元素，就可以对它进行下标操作：
int *p = &ia[2]; // ok: p points to the element indexed by 2 int j = p[1]; // ok: p[1] equivalent to *(p + 1), // p[1] is the same element as ia[3] int k = p[-2]; // ok: p[-2] is the same element as ia[0]

C++ 允许计算数组或对象的超出末端的地址 ，但不允许对此地址进行解引用操作。而计算数组超出末端位置之后或数组首地址之前的地址都是不合法的。例如：vector的end；
const size_t arr_size = 5; int arr[arr_size] = {1,2,3,4,5}; int *p = arr; // ok: p points to arr[0] int *p2 = p + arr_size; // ok: p2 points one past the end of arr //use caution -- do not dereference!

使用指针遍历数组如下：C++ 允许使用指针遍历数组。和其他内置类型一样，数组也没有成员函数
const size_t arr_sz = 5; int int_arr[arr_sz] = { 0, 1, 2, 3, 4 }; // pbegin points to first element, pend points just after the last for (int *pbegin = int_arr, *pend = int_arr + arr_sz; pbegin != pend; ++pbegin) cout << *pbegin << ' '; // print the current elemen

const限定符表示的概念的复习与加深 ：

 

const对象是只读的，所以必须初始化。非const对象的值可以赋值给const对象，但是反过来不行！！

(a) int i = -1; (b) const int ic = i; (c) const int *pic = &ic; (d) int *const cpi = &ic;//error cpi 是一个指向 int 型对象的 const 指针,不能用 const int型对象 ic 的地址对其进行初始化。 (e) const int *const cpic = &ic;


vector<T>::const_iterator itr说明迭代器指向的对象是const的
而const vector<T>::iterator itr 说明迭代器本身是const的
const int *p  p指向的对象是const的；int* const p p本身是const的

double dval = 3.14159; // dval is not const const double *cptr=&dval; *cptr = 3.14159; // error: cptr is a pointer to const double *ptr = &dval; // ok: ptr points at non-const double *ptr = 2.72; // ok: ptr is plain pointer cout << *cptr; // ok: prints 2.72

指向 const 的指针 cptr 实际上指向了一个非 const 对象。尽管它所指的对象并非 const，但仍不能使用 cptr 修改该对象的值。本质上来说，由于没有方法分辩 cptr 所指的对象是否为 const，系统会把它所指的所有对象都视为 const。
如果指向 const 的指针所指的对象并非 const，则可直接给该对象赋值或间接地利用普通的非 const 指针修改其值：毕竟这个值不是 const。重要的是要记住：不能保证指向 const 的指针所指对象的值一定不可修改。

在实际的程序中，指向 const 的指针常用作函数的形参。将形参定义为指向 const 的指针，以此确保传递给函数的实际对象在函数中不因为形参而被修改。


指针和typedef
          typedef string *pstring;
          const pstring cstr;
把cstr理解为 const string *cstr;是错误的，原因在于将typedef当作文本扩展了。声明 const pstring 时，const 修饰的是 pstring 的类型，这是一个指针。所以应该理解为string *const cstr;这里没有初始化！const对像必须初始化

const限定符修饰谁很关键。const 限定符既可以放在类型前也可以放在类型后：
string const s1; // s1 and s2 have same type, const string s2; // they're both strings that are const const pstring cstr; pstring const cstr;//same,必须初始化 const int *pi;int const *pi;//same

c风格字符串 ：以空字符null结束的const char字符数组,而string不是以空字符结尾的 ，c_str（）可以返回c风格字符串（const char＊）；string与c风格字符串转换问题主要出现在调用别人写的函数时。但是如果函数是fun（char＊）使用c_str()则不行；这时使用copy（char *buf,size_type num,size_type index）则把字符串的内容复制或写入既有的c_string或 字符数组内,这里的buf要事先分配好内存空间malloc（）。注意自己实现的函数坚持使用c＋＋风格，一般c风格程序也应该使用const char*作为形参！
string str="hello"; char *pc1=(char*)malloc(str.size()*sizeof(char)+1);//确保存储空间 size_t num=str.copy(pc1,str.size(),0); free(pc1);

string本质上是一个容器
typedef basic_string <char> string;
typedef basic_string <wchar_t> wstring;

cstring 是 string.h 头文件的 C++ 版本，而 string.h 则是 C 语言提供的标准库。
cstring提供的函数假定它们所修改的字符串具有足够大的空间接收本函数新生成的字符，程序员必须确保目标字符串必须足够大 。比如copy的例子。这个足够的空间如何满足：1,定义目标字符串时已经分配足够的空间；2.重新分配空间
要加深数组与指针的密切关系的理解。用c风格字符串不一定总是用char＊，也可以使用char［］。
string str="hello"; cout<<funC((char*)str.c_str()); char *pc1=(char*)malloc(str.size()*sizeof(char)+1); size_t num=str.copy(pc1,str.size(),0); free(pc1); char a[30]="hello "; const char *b="world"; strcat(a,b);

c++的string支持关系操作符；而c风格字符串的比较必须使用cstring库中的strcmp（）函数；类似的还有strcat

重申！设计到c风格字符串的复制；连接等操作均要保证目标缓冲区具有足够大的空间！！！！
这里要坚持一种分格。对目标字符串我们要事先分配空间，然后随着程序的进行再使用realloc重新设定空间，若一开始未指定空间，realloc失败，其必须知道旧空间大小！！。
方法一：
char *a=(char*)malloc(10);//char *a=new char[10];动态分配堆内存，c＋＋应使用这中风格 strcpy(a,"hello ")； //a="hello";//若这样，则分配空间的作用失去了。error这种方式在初始化目标缓冲区时是错误的，使用strcpy！！！！ const char *b="world"; a=(char*)realloc(a,30); if(a){ strcat(a,b); cout<<a<<endl; } else { cout<<"failed"<<endl; } free(a);//delete []a;
方法二：
char a[30]="hello ";//这种方法解洁，而且充分利用了数组的名称在表达式中就是其第一个元素的指针，但是需要事先和知道数组长度，会有溢出危险。所以建议采用动态创建数组 const char *b="world"; strcat(a,b);

总结：
const char *a="hello"; const char *b="world"; size_t len=strlen(a)+1;//别忘了strlen不计算null，这里要将null算入。 size_t glen=len+strlen(b)+1; char ＊res=new char[len]; strcpy(res,a); strncat(res," ",2); strcat(res,b); delete[] res;

字符串字面值是c风格字符串的实例，永远不要忘记字符串结束符 null,这对标准库函数的实现影响！
          
const char ca[] = {'h', 'e', 'l', 'l', 'o'};// not null-terminated数组显示初始化无须指定个数，编译器可以自己获得。这里ca[5] const char *cp = ca;// disaster: cp和ca isn't null-terminated cout << strlen(cp) << endl; cout<<strlen(ca)<<endl;

标准库函数 strlen 总是假定其参数字符串以 null 字符结束，当调用该标准库函数时，系统将会从实参 ca 指向的内存空间开始一直搜索结束符，直到恰好遇到 null 为止。strlen 返回这一段内存空间中总共有多少个字符，无论如何这个数值不可能是正确的。

如果必须使用 C 风格字符串，则使用标准库函数 strncat 和 strncpy 比 strcat 和 strcpy 函数更安全,特别是在复制和串连字符串时，一定要时刻记住算上结束符 null。在定义字符串时要切记预留存放 null字符的空间
char largeStr[16 + 18 + 2]; // to hold cp1 a space and cp2 strncpy(largeStr, cp1, 17); // size to copy includes the null strncat(largeStr, " ", 2); // pedantic, but a good habit,此时largeStr的length为17，原来用于结束 largeStr 的 null 被新添加的空格覆盖了，然后在空格后面写入新的结束符 null。 strncat(largeStr, cp2, 19); // adds at most 18 characters, plus a null

创建动态数组
数组类型的变量有三个重要的限制：数组长度固定不变，在编译时必须知道其长度，数组只在定义它的块语句内存在。实际的程序往往不能忍受这样的限制——它们需要在运行时动态地分配数组。虽然数组长度是固定的，但动态分配的数组不必在编译时知道其长度，可以（通常也是）在运行时才确定数组长度。与数组变量不同，动态分配的数组将一直存在，直到程序显式释放它为止,在不使用分配的地址之前不能delete。
使用new／delete c中使用malloc／free。实质上new是在堆上动态分配内存
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


使用数组初始化vector
const size_t arr_size = 6; int int_arr[arr_size] = {0, 1, 2, 3, 4, 5}; // ivec has 6 elements: each a copy of the corresponding element in int_arr vector<int> ivec(int_arr, int_arr + arr_size);//当然范围可以小

另外两个例子：加深对指针类比于迭代器和new/delete.
cout<<"enter number(ctrl+d)"<<endl; vector<int> vint; int temp; while(cin>>temp) { vint.push_back(temp); } int *res=new int[vint.size()]; /* for(vector<int>::iterator itr=vint.begin();itr!=vint.end();++itr) { *res=*itr;//res指针类似于迭代器，这里我们可以这样方便的进行赋值 ++res; } for(int *pbegin=res,*pend=res+vint.size();pbegin!=pend;++pbegin)//这里貌似没错，但是注意，上一步已经改变了res的位置，实质上res已经到了数组末尾的下一个，即哨位！！！ { cout<<*pbegin<<endl; } delete[] res;//！！！此时res所指地址为哨位，delete会报指针错误！！！ */ //!!!!!!!!!!!所以对res修改其值的时候不能直接对res这个指针进行指针算术操作！！！！修改如下： int *tp=res; for(vector<int>::iterator itr=vint.begin();itr!=vint.end();++itr,++tp) { *tp=*itr;//指针类似于迭代器，这里我们可以这样方便的进行赋值 } for(int *pbegin=res,*pend=res+vint.size();pbegin!=pend;++pbegin) { cout<<*pbegin<<endl; } delete[] res;


例二：
#include <iostream> #include <vector> #include <string> #include<cstring> using namespace std; int main() { vector<string> svec; string str; // 输入 vector 元素 cout << "Enter strings:(Ctrl+Z to end)" << endl; while (cin >> str) svec.push_back(str); // 创建字符指针数组 char **parr = new char*[svec.size()]; // 处理 vector 元素 size_t ix = 0; for (vector<string>::iterator iter = svec.begin(); iter != svec.end(); ++iter, ++ix) { // 创建字符数组 char *p = new char[(*iter).size()+1];//null位 // 复制 vector 元素的数据到字符数组 strcpy(p, (*iter).c_str()); // 将指向该字符数组的指针插入到字符指针数组 parr[ix] = p; } // 释放各个字符数组 for (ix =0; ix != svec.size(); ++ix) delete [] parr[ix]; // 释放字符指针数组 delete [] parr; return 0; }
这个例子是对new/delete对的理解。不是说new一个就要跟着一个delete，实质是对new的堆空间进行delete，所以这里delete parr［ix］就是delete了char *p = new char[(*iter).size()+1]分配的空间

 

多维数组其实就是数组的数组 ，所以由多维数组转换而成的指针类型应是指向第一个内层数组的指针。
int ia[3][4]; // array of size 3, each element is an array of ints of size 4 int (*ip)[4] = ia; // ip points to an array of 4 ints。声明中，圆括号是必不可少的 ip是int［4］类型的指针 ip = &ia[2]; // ia[2] is an array of 4 ints

用 typedef 简化指向多维数组的指针
typedef int int_array[4];//typedef int[4] int_array is error.typedef string *pstring---这里pstring是string*的别名 int_array *ip = ia;
可使用 typedef 类型输出 ia 的元素：

for (int_array *p = ia; p != ia + 3; ++p) for (int *q = *p; q != *p + 4; ++q) cout << *q << endl;