C++ primer plus 第四章（复合类型）笔记

1 数组

（1）必须保证下标的有效性

（2）sizeof 对数组的作用
①如果是对某个元素 如：sizeof a[2]得到的将是a这个数组的类型的长度
（char 1个字节 ，int 4个，double 8个等）
②对数组名a
sizeof a 得到的是a数组的长度 ，即元素个数 x 类型的长度

#include<iostream>
using namespace std;
int main()
{
	long a[]={24,45,4.8,89};//4.8被转换为整数4.
	char b[4]={'h','i',112,'\0'};//正确。112在char的范围内
	for(int i=0;i<4;i++)
		cout<<a[i]<<" "<<b[i]<<endl<<sizeof a<<endl;//sizeof a 将返回整个a的字节数16
	return 0;
}

2 字符串

（1）这个东西很麻烦，特别是输入输出，下标问题。需要多注意，不然输出的就是一堆奇怪的乱码>_<

（2）作为一个字符串，它必须要有’\0’来结尾。否则会在结尾的地方输出奇怪的字符。

#include<iostream>
using namespace std;
int main()
{
	char a[3]={'3','d','g'};//在g的后面还有几个奇怪的字符
	cout<<a<<endl;
	char b[4]={'3','d','g','\0'};//g后面没有字符
	cout<<b<<endl;
	return 0;
}

（3）也可以用双引号来初始化字符串，这时不需要加’\0’。但是要保证字符数组足够大（至少要有一个空位来存’\0’。）
这种也被称为字符串常量或字符串字面值。
如：char a[12]=“sdfsdf”;
char b[]=“sddfggre”;

(4)字符串的拼接

#include<iostream>
using namespace std;
int main()
{
	cout<<"I am" " boy.\n";//两个是连在一起的，
	//注意boy到它前面的引号之间有空格，输出同下。
	cout<<"I a"
	"m boy.\n";//输出为I am boy.
	return 0;
}

第一个字符串的’\0’被第二个字符串的第一个字符取代
（4）字符串的输入
①用cin输入字符串只能输入单词，遇到空格就会结束输入。和scanf（%s）一样
所以要用cin.getline(字符串名称，最大读取长度+1）
比如cin.getline(a,21);那么最多可以读取20个字符，最后一个空位用来存放’\0’;

②cin.get(字符串名称，最大读取长度+1）
如cin.get(a,21)
和cin.getline()差不多，但是它会将换行符留在输入队列中
所以，下一次读取需要用cin.get()来消除换行符。
也可以用这个来查看输入队列的下一个字符是什么。

#include<iostream>
using namespace std;
int main()
{
	char a[11];//最多放10个字符，最后一个是'\0';
	char b[11];
	cin.get(a,11);//把11改为12，并且输入大于等于11，会弹出对话框，说a的栈炸了。
	cin.get(b,11);
	cout<<a<<endl<<b;//如果输入a之后，没有get()，如果输入的字符长度超过10，则超出的字符会赋值给b
	return 0;//如果没有超过10，则b为\n,输出时光标移到下一行。
}

（5）空行和其他输入输出问题
如果输入的字符比指定的多，则getline（）和get（）会把剩下的字符留在输入队列中
getline（）还会有失效位，并关闭后面的输入

#include<iostream>
#include<string>
using namespace std;
int main()
{
	char a[12];
	char b[12];
	cin.getline(a,12);
	cin.clear();//如果不加上这句，那么当a输入过多的字符时，b不会接收到
	cin.getline(b,12);
	cout<<a<<endl<<b<<endl;
	return 0;
}

注意输入数字后，也要用cin.get()来消除换行符。

3 string类

（1）string 类将字符串作为一种变量来处理。
string类可以直接赋值，而不用strcpy函数。也支持+操作，将两个字符串合并，+=操作将一个字符串附加到另一个的末尾。

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string a,b;
	getline(cin,a);
	getline(cin,b);
	cout<<a<<endl<<b<<endl<<a+b<<endl;
	return 0;
}

（2）string类输入
用cin可以读入一个单词。用getline(cin,变量名）可以读入整行。

（3）如果用string 类的变量名a, 则a.size()表示a的长度。

4 结构体和共用体

（1）结构体可以在定义的时候进赋值
c++中可以省略关键字struct

#include<string>
#include<iostream>
using namespace std;
struct ZX{
	string a;
	int b;
	double c;
};
int main()
{
	ZX s={"asdsa",23,123.45};//可以省略关键字struct
	cout<<s.a<<endl<<s.b<<endl<<s.c<<endl;
	return 0;
}

（2）同一种结构体之间可以赋值，这被称为成员赋值，成员是数组也可以

#include<string>
#include<iostream>
using namespace std;
struct ZX{
	string a;
	int b;
	double c;
	int k[20];
};
int main()
{
	ZX s={"asdsa",23,123.45,1},T;//声明结构体变量s，T
	T=s;
	cout<<s.a<<endl<<s.b<<endl<<s.c<<endl;
	cout<<T.a<<endl<<T.b<<endl<<T.c<<endl<<T.k[0]<<" "<<T.k[1];//k[0]为1，k[1]为0
	return 0;
}

（3）共用体union
和结构体差不多，但是每次只储存一个值，它的长度为最大成员长度。

5 枚举

（1）枚举enum
枚举没有算术运算，可以转换为整型，再进行算术运算。

#include<string>
#include<iostream>
using namespace std;
int main()
{
	enum a {q,d,vb,sd=123,ad};//枚举的值从0开始往后加一，q=0，d=1，ad=124.
	int t=vb;
	a T;
	T=a(4);//在枚举的范围内都可以赋值
	t++;//t可以进行算术运算，但是T不能。
	cout<<q<<' '<<sd<<' '<<ad<<endl;
	cout<<t<<' '<<T<<endl;
	return 0;
}

6 指针

(1) 使用new来分配内存
new将从堆中分配内存

#include<iostream>
#include<string>
using namespace std;
int main()
{
	int *p=new int;
	*p=122143434;
	cout<<*p<<endl;
	delete p;//千万不要删除两次。
	cout<<p;//删除p所在的内存后，仍然可以用p这个指针。
	return 0;
}

（2）动态数组
动态数组和一般的变量差不多，使用也很简单。

#include<iostream>
#include<string>
using namespace std;
int main()
{
	cout.setf(ios_base::fixed,ios_base::floatfield);//让cout输出小数六位
	int * p=new  int [200000000];//可以开到九位数的数组。
	p[0]=1;p[2]=4;
	double *t=new double [2000];//格式
	t[2]=123.34;t[3]=213.56;
	cout<<p[0]<<endl<<p[2]<<endl<<t[2]<<endl<<t[3];
	delete [] p;
	delete []t;//记住一定要加上方括号，格式要对应
	return 0;
}

（3）字符串
new char ps；
cout<<ps;输出的是字符串
cout<<(int*)ps;输出的是字符串的地址

#include<iostream>
#include<string>
using namespace std;
int main()
{
	char *ps="sasghhg";//这是可以的。cin>>p或cin>>*p都不行，会弹出对话框.
	cout<<ps<<endl;
	const char r[120]="zasdgfddfggfsadsahggghfrtyrtd";
	char ani[120]="gffdjkgfdjkgerkjtjkerkjtkertejktrdgh";
	ps=ani;//const变量r的值不能赋给p，ani可以。
	cout<<ps<<endl;
	ps=new char [21];
	strcpy(ps,r);//strcpy会无视ps的长度，可能会越界。
	ps[20]=0;
	cout<<ps<<endl;//strcpy可以用const类型的变量。
	strncpy(ps,ani,20);//第三个参数是最大长度。
	//ps[20]=0;//记得加'\0';
	cout<<ps<<strlen(ps)<<endl<<(int*)ps<<endl;//(int*)输出ps的地址，ps输出字符串。
	return 0;
}

(4)结构体
指向结构体的指针p可以用’->'间接成员运算符来访问结构体的成员。
也可以用（*p).成员名，来访问结构体的成员。

#include<iostream>
#include<string>
using namespace std;
struct inr{
	int a,b;
	char name[32];
};
int main()
{
	inr *p=new inr;
	p->a=22;
	p->b=99;
	cin.getline(p->name,32);//32为最大的字符长度31+1
	cout<<p->a<<endl<<p->b<<endl<<p->name<<endl;
	cout<<(*p).a<<endl;
	delete p;
	return 0;
}

（5）类型组合
①指针数组

#include<iostream>
using namespace std;
struct t{
	int a,b;
	char name [30];
};
int  main()
{
	t s0,s1,s2;
	t *p=&s0,*p1=&s1;
	p->a=99;
	p->b=12;
	p1->a=23;
	const t *pa[3]={&s0,&s1,&s2};//指针数组
	cout<<pa[0]->a<<" "<<pa[0]->b<<endl;
	const t **ppa=pa;//指向指针数组的指针。
	cout<<(*ppa)->a;//pa[0]，就是s0
	cout<<(*(ppa+1))->a;//pa[1]，就是s1,括号要用对
	return 0;
}

vector和array

这里介绍的有点简略，十六章会详细介绍。。。
vector不可以用花括号赋值，array可以。

#include<vector>
#include<iostream>
#include<array>
using namespace std;
int main()
{
	int t=45;
	vector<int> p(t);//vector的长度可以用变量来表达
	vector<int>a;//数组的初始长度为0
	vector<int> b(100);//数组的初始长度为100
	array<int,100>c={1,2,3,4};//int类型的，长度为100的数组
	c.at(2)=233;//c[2]=233;
	cout<<c[0]<<" "<<c[1]<<" "<<c[2]<<" "<<c[3]<<endl;
	array<int,100>e;
	e=c;//可以直接对相同长度的array变量赋值。
	cout<<e[0]<<" "<<e[1]<<" "<<e[2]<<" "<<e[3]<<endl;
	return 0;
}