C++（1）

C++(1)

常量定义

作用：用于记录程序中不可更改的数据

C++定义常量两种方式

#define 宏常量： #define 常量名 常量值
通常在文件上方定义，表示一个常量

const修饰的变量 const 数据类型 常量名 = 常量值
通常在变量定义前加关键字const，修饰该变量为常量，不可修改

运算

除
10 / 3 = 3 //两个整数相除结果依然是整数 、除数不可以为0
//取模
10 % 3 =1 //取模运算时，除数也不能为0 两个小数不可以取模
sizeof:统计数据类型所占内存大小 sizeof( 数据类型 / 变量)

三目运算符
表达式1 ? 表达式2 ：表达式3
程序流程
Switch:
switch语句中表达式类型只能是整型或者字符型,case里如果没有break，那么程序会一直向下执行

break语句
跳出选择结构或者循环结构

多条件的if语句：if(条件1){ 条件1满足执行的语句 }else if(条件2){条件2满足执行的语句}... else{ 都不满足执行的语句}

continue语句,循环语句中跳过本次循环中余下尚未执行的语句，继续执行下一次循环
goto语句时，会跳转到标记的位置

数组

一维数组定义:

1. 数据类型 数组名[ 数组长度 ];
2. 数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};
3. 数据类型 数组名[ ] = { 值1，值2 ...};

数组/元素所占内存空间大小 sizeof(arr) / sizeof(arr[0]

数组地址
首地址(int)arr

元素地址
&arr[0]=0x7fffffffda40
(long)&arr[0] =140737488345664
(?linux下不能用int要转long)

二维数组
第二种最直观
数据类型 数组名[ 行数 ][ 列数 ];
数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};

函数

种类:无参无返\有参无返\无参有返\有参有返

函数的声明可以多次，但是函数的定义只能有一次

函数的分文件编写 .h的头文件 写函数的声明 /.cpp的源文件 写函数的定义

指针

通过指针间接访问内存
定义语法： 数据类型 * 变量名
所有指针类型在32位操作系统下是4个字节 64位是8字节

//1、指针的定义
int a = 10; //定义整型变量a

//指针定义语法： 数据类型 * 变量名 ;
int * p;

//指针变量赋值
p = &a; //指针指向变量a的地址
cout << &a << endl; //打印数据a的地址
cout << p << endl;  //打印指针变量p

//2、指针的使用
//通过*操作指针变量指向的内存  解引用
cout << "*p = " << *p << endl;

空指针和野指针

空指针：指针变量指向内存中编号为0的空间，初始化指针变量，空指针指向的内存是不可以访问的

int * p = NULL;//指针变量p指向内存地址编号为0的空间

野指针：指针变量指向非法的内存空间

const修饰指针

1. const修饰指针 — 常量指针
2. const修饰常量 — 指针常量
3. const既修饰指针，又修饰常量

	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a; 
	p1 = &b; //正确
	//*p1 = 100;  报错
	

	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //const既修饰指针又修饰常量
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误
	技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量

数组中的指针

	int arr[] = {1,2,3,4};
	int *p = arr;
	cout << (long)arr << endl;  140737488345696
	cout << arr << endl;  0x7fffffffda60
	cout << p << endl;   0x7fffffffda60
	cout << *p << endl;   1

指针访问数组中元素 就记住p是地址

	int * p = arr;  //指向数组的指针  
	for (int i = 0; i < 10; i++)
	{
		//利用指针遍历数组
		cout << *p << endl;
		p++;
	}

地址传递会改变实参

void swap2(int * p1, int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
swap2(&a, &b); //地址传递会改变实参

结构体

定义：struct 结构体名 { 结构体成员列表 }；
创建：

• struct 结构体名 变量名
• struct 结构体名 变量名 = { 成员1值 ， 成员2值…}
• 定义结构体时顺便创建变量

//结构体数组

	struct student arr[3]=
	{
		{"张三",18,80 },
		{"李四",19,60 },
		{"王五",20,70 }
	};

结构体指针

	struct student * p = &stu;
	
	struct student stu = { "张三",18,100, };
	
	struct student * p = &stu;
	
	p->score = 80; //指针通过 -> 操作符可以访问成员

	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;

结构体嵌套结构体 结构体中的成员可以是另一个结构体

struct teacher
{
    //成员列表
	int id; //职工编号
	string name;  //教师姓名
	int age;   //教师年龄
	struct student stu; //子结构体 学生
};
	struct teacher t1;
	t1.id = 10000;
	t1.name = "老王";
	t1.age = 40;

	t1.stu.name = "张三";
	t1.stu.age = 18;
	t1.stu.score = 100;

结构体做函数 函数内能访问结构体属性（同函数传递一样，地址传递会修改主函数中的数据）

//值传递
void printStudent(student stu )
{
	stu.age = 28;
	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
}
printStudent(stu);


//地址传递
void printStudent2(student *stu)
{
	stu->age = 28;
	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
}
printStudent2(&stu);

结构体加const 防止误操作修改结构体变量

void printStudent(const student *stu) //加const防止函数体中的误操作
{
	//stu->age = 100; //操作失败，因为加了const修饰
	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;
printStudent(&stu);
}