【C++ Primer】第四章学习笔记 （复合类型）

一，数组

1，数组只有在定义时候才能使用初始化，不能将一个数组赋给另一个数组。

int a[4]={1,2,3,4};//正确

int a[4];

a[4]={1,2,3,4};//不正确

int b[4]=a;//不正确

2，初始化数组时候，提供少于数组元素数目的部分数值，则将剩余赋值为0;

float a[5]={1,2};

3，如果初始化数组时候，方括号内[ ]为空。C++编译器将计算元素个数。

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

int number=sizeof(a)/sizeof(short);//计算元素个数（可见字符个数）

char a[ ]={'a','b','c','d','e'};//必须是char 类型的 字符串

strlen(a);//计算可见字符串个数

二，字符串

1，字符串结尾字符为'\0'(ASCII码为0)

char a[5]={'a','b','c','d','e'};// 纯字符数组，最好不要当做字符串处理

char a[5]={'a','b','c','d','\0'};//结尾为空字符,可以当做字符串处理

char a[15]="I am a student";//系统自动在最后一个字符加上'\0';

char a[]="I am a student";//系统自动算字符个数

【remember】确定字符串所需最短数组时候，不要忘记结尾空字符串。

"s" 表示两个字符 's'和'\0';

2，字符串输入:面向行输入getline()

char a[20]; //必须为char类型的 字符数组

cin.getline(a,20);//将用户输入的字符 读入到一个包含20个元素的 a数组中。

cout<<strlen(a);//输出输入字符个数

如果输入的字符多于19个（1个'\0'），geline仅仅取前19个字符。而多于的不会留在输入队列中（区别与get()）

3，字符串输入：面向行输入get()

char a[2];

char b[2];

cin.get(a,2);

cin.get(b,2);

cout<<strlen(a)<<endl;

cout<<strlen(b)<<endl;

输入：abcd

输出：1 1 如果是getline()则输出：1 0

get()取的是n-1个可见字符，数组声明为 n 则读取n-1字符，最后一个设置为'\0';遇到换行符则将其留在输入队列。

第二次调用cin.get()读取第一个字符为 换行符。

【难点】两个cin 为何只允许输入一次？？

char a[5];

cin.get(a,5);

cin.get(); //读取输入队列中换行符并丢弃。防止下次读换行符时认为结束而终止。造成第二次不能输入

cout<<a[1]<<endl;



char b[5];

cin.get(b,5);

cout<<b[0]<<endl;

三，string类型

1，连接两个字符串

string str1,str2,str3;

str3=str1+str2;

/*上面是C++做法，下面是C语言做法*/

strcpy(str3,str1);//将str1复制到str3中

strcat(str3,str2);//将str2添加到str1中

2，未被初始化的字符数组，第一个空字符出现的位置是随机的。

char a[10];

cout<<strlen(a);

输出 4 //0-9 随机

四，结构类型

1，struct 用法

struct node

{

int data;

node *next;

}p1;//声明结构类型的变量

2，共用体 union

一种数据结构格式存储不同结构类型，但是每次只能使用一个类型。

struct node

{

int data;

union id

{

long id_num;

int id_num;

}

node *next;

}p1;//

/*一点了，该睡觉了……未完待续*/

--------------------------------------------------------------------------------------------------------------

/*元旦三天假期，偷懒了一下。继续奋战*/

3，枚举 enum

用法：enum 枚举名{所包含的元素};

默认枚举值： enum name{red,orange,yellow,green,blue}//默认，red=0;orange=1;yellow=2……

设置枚举值：enum name{one=1,two=2,four=4,a,b};//默认指定值 four之后，a=four+1=5;b=6

声明变量：name band;

band=red;//valid 在不进行强制转换情况下，只能将定义枚举时使用的枚举量赋给这种枚举的变量

band++; //invalid 没有为枚举定义算术运算

band=2; //invalid 将整型赋值给枚举类型将导致类型错误

int color=2+red// valid 结果为int型，2

band=band(2);//按照{two=2} band=two; 可以通过强制转换的方式 将整型 转化为 枚举类型

4，指针和自由存储空间

1）用法： int a=6;

int *p;// ‘*p’ 表示存储在p地址处的值

p=&a;//指针为p，存储的是值的地址，而不是值本身。

或者写为：int* p=&a;//将指针 p的值设置为&a 而不是将 *p的值

2）指针的危险

long * length;

*length=25365;//length 确实是一个指针，但是没有说明指向哪里，原因是没有初始化指针length

3） new/delete申请与释放内存

int * pn=new int ;//分配int型内存，然后把该内存块地址赋值给指针

*pn=100;//给声明的内存单元赋值

delete pn;//释放pn指向的内存单元，不会删除pn指针本身（pn可以指向另一个新分配的内存块）

【注意】不要尝试释放已经释放的内存块,delete pn;之后再delete pn 会有意想不到的错误

不能使用delete释放声明变量所获得的内存（只能释放new申请的）int *p=&a;//不能delete

4）new创建动态数组

int *a=new int[100];

delete [] a;//[]告诉程序释放的是数组

【原则】

不要使用delete释放不是new分配的内存

不要使用delete释放同一个内存块两次

如果使用new[ ]为数组分配内存，则应使用delete[ ]来释放

如果使用new 为变量分配内存，则应使用delete来释放内存，对空指针应用delete是安全的

五，指针、数组和指针算术

1，double a[3]={100,200,300};

double *p=a;//p指针指向的是数组a的第一个元素的地址

cout<<"地址为："<<p+1<<"存储的值为："<<*(p+1)<<endl；//输出的是a[1]的地址和a[1]的值

说明：p+1 增加的量等于 p指针指向类型的字节数（double 8字节）

C++将数组名解释为数组第一个元素的地址

2，sizeof作用于 数组显示数组占用的字节数，作用于指针显示指针长度

程序：

#include "stdio.h"
int main()
{
double a[3]={100.0,200.0,300.0};
double *p=a;
printf("显示数组占用字节数：%d\n",sizeof(a));//输出24=3*8
printf("显示指针个数：%d\n",sizeof(p));//输出4=3个可见元素加上一个结束符
}

3，数组名是第一个元素地址，但是cout对象认为char 数组的地址为字符串地址

程序：

#include "stdio.h"
#include <iostream>
using namespace std;
int main()
{
double a[3]={100.0,200.0,300.0};
char b[5]="rose";
cout<<"打印double型数组名a:"<<a<<endl;//输出数组第一个元素地址
cout<<"打印char型数组名b:"<<b<<endl;//输出字符串
}

cout 输出char数组时，从第一个字符元素输出一直到遇到空字符'\0'

4，不要使用常量和未被初始化的指针来接受输入

char *p;

const char *a="rose";

cin>>p;//不正确

cin>>a;//不正确

5，一个使用new和delete的程序范例

#include "stdio.h"
#include <iostream>
using namespace std;
char *getname();
int main()
{
char *name;
name =getname();
cout<<name<<" at "<<(int *)name <<endl;
delete []name;

name =getname();
cout<<name<<" at "<<(int *)name <<endl;
delete []name;
}
char *getname() //如果要建立大量数组的时候，可以根据要存储变量的大小动态分配内存大小
{
char temp[80];
cout<<"Enter last name:";
cin>>temp;
char *pn=new char[strlen(temp)+1];
strcpy(pn,temp);
return pn;
}

程序说明：两次输出的地址是一样的。如果去掉delete []name 则 已经使用但未被释放的地址无法使用