【阅读笔记】c++ Primer Plus——第四章

复合类型

数组

• 声明数组的时候，需要把数组的类型，名字，长度确定下来
  如果赋的值超过数组长度会报错，在定义数组的时候需要谨慎，需要防止超出数组上限

  int arr[10];
  

字符串

把一系列字符存放在char数组中去，以\0为结束符(c风格字符串)

char a[5] = {'a', 'd', '\0', 'w', 'e'};
输出结果

• strlen()获得字符串长度
  string类,将字符串作为一种数据类型

string test = "hello";

对比

• 不需要手动定义长度,可以直接赋给另一个字符串

string str1 = "hello";
string str2;
str2 = str1;
char chr1[10] = "hello";
char cha2[10];
cha2 = cha1 # 报错
cout << str2 << endl;

结构

结构定义struct

• 结构声明的位置
  • 跟在函数开头后面，作为局部声明，只能在该函数中用
  • 在文件开头，作为外部声明，可以让所有函数都能使用
• 亦可以以结构数组的形式使用

struct inflatable{
    char name[20];
    float volume;
    double price;
}
inflatable arr[10];

共用体(union)，能够存储不同的数据类型，但只能同时存储其中一种类型

struct test
{
    int id_int;
    union id{
        long id_num;
        int id_num2;
    }id_val;
};
test test1 = {
    888,
};
test1.id_val.id_num = 33;
test1.id_val.id_num2 = 2312321312;
cout << "id_num" << test1.id_val.id_num << endl;
cout << "id_num2" << test1.id_val.id_num2 << endl;

指针和自由存储空间

• 指针，用于存储指的地址
  • 运算符称作间接指运算符或解除引用运算符
  • 指针声明必须和指针指向的数据类型一致
    不能对指针直接赋数值

int i = 10;
int* x ;
x = &i;
cout << "x的值" << x <<endl;
cout << "*x的值" << *x <<endl;
int* y;
*y = 4564; // 会报错
*x = 4564;

• 使用new来分配内存，将找到一个长度正确的内存块，并返回该内存的地址
  delete释放内存，只会释放由new创建的内存块

  int* pt = new int;
  *pt = 1001;
  cout << "pt的值" << pt << endl;
  cout << "pt的地址" << *pt <<endl;
  delete pt;
  cout << "pt的值" << pt << endl;
  cout << "pt的地址" << *pt <<endl;  // 会报错
  

  

• 静态联编，在程序编译时给数组分配内存

• 动态联编，在程序运行阶段，需要用到数组时通过new来创建，不需要用到就不创建
  指针、数组和指针算术

• 指针加1，加的是指针类型的字节数

  • arr[1] 相当于 *(arr + 1)

double arr[3] = {232.323, 54545.4545, 87878.78};
short sta[3] = {1, 2, 3};
double * parr = arr;
short * psta = sta;
cout << "parr的地址是" << parr << endl;
parr++;
cout << "parr的新地址是" << parr << endl;
cout << "psta的地址是" << psta << endl;
psta++;
cout << "psta的新地址是" << psta << endl;

• strcpy(a, b)，把b中的内容赋值到a当中去
  new创建动态结构，内存是在运行时才进行分配

• • 通过箭头成员运算符(->)来调用成员结构中的成员变量 114页 4.11图
    c++的三种存储方式：自动存储，静态存储，动态存储
• • 自动存储，函数内部定义的常规变量使用自动存储空间
  • 静态存储，整个程序执行期间都存在的存储方式
    • 在函数外面定义的内容
    • 在变量声明的时候使用了static关键字
  • 动态存储，通过new和delete来创建和释放变量
    • 开辟的内存地址是存放在自由存储空间下的
    • 如果只new不delete，内存可能会因为声明周期的缘故被释放掉，但动态分配的变量或结构扔存在自由存储空间中，会导致指向这些内存的指针是无效的，会出现内存泄露的情况

类型组合

• 数组、结构和指针通过不同的方式进行组合
  auto，根据赋值的类型来定义

struct test
{
    int i;
}
test arr1, arr2, arr3;
arr1.i = 1000;
test *pa = &arr2;
pa->i = 2000;

test arr[3];
arr[0].i = 3000;
(arr + 1) ->i = 4000;
const test *parr[3] = {&arr1, &arr2, &arr3};
cout << parr[1]->i << endl;

const test** ppa = parr;
auto ppb = parr;
cout << (*ppa)->i << endl;
cout << (*(ppb))->i << endl;

数组的替代品

vector，自动完成new和delete的操作

// n_elme可存储的个数
vector<Typename> vt(n_elme)

array，长度固定，使用静态内存分配，比数组更方便、更安全

array<Typename, n_elme>arr