（C++基础随笔） 01 c基础

基础语法

变量的意义

方便我们管理内存空间

常量的定义

1、#define

2、const

sizeof()

输出占用的内存空间

指针

是一个变量，用于记录内存地址的

指针定义和使用

int a=10;
int *p;//定义了一个指针
p=&a;//&符号获取到的是a在内存中的地址

//使用指针时要解引用，指针前加上*就是解引用，获取指针指向的数据
*p=1000

指针所占的内存空间

C++下规定，32位系统下所有的指针都占4字节，64位系统下所有的指针都占8字节

空指针和野指针

空指针

指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针不能取地址（0~255为系统占用内存，不允许用户访问）

int *p=NULL;
*p=100;//会报错

野指针

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

int *p=(int *)0x1100;//运行时会报错

const修饰指针

const修饰指针—常量指针

用途：指针的指向可以修改，但是指针指向的值不可以修改

const int *p=&a;

//解释如下
*p=20;//修改指向的值会报错
p=&b;//但是修改指向不会报错

const修饰常量—指针常量

用途：和常量指针相反，指针指向不可以改，但是指针指向的值可以改

int * const p=&a;

//解释如下
*p=20;//修改指向的值不会报错
p=&b;//但是修改指向会报错

const既修饰指针又修饰常量

用途：指针指向和指针指向的值都不可以改

const int * const p=&a;

//解释如下，都会报错
*p=20;
p=&b;

指针和数组

目的：利用指针访问数组

int arr[10]={1,2,3,4,5,6,7,8,9,10};
int * p =arr;//数组名就是数组首地址

for(int i=0;i<10;i++){
    cout<<*p<<endl;
    p++;//因为内存中arr是顺序存放的，让指针向后偏移4字节指向下一个元素
}

指针和函数

目的：利用指针(内存地址)作为函数参数，可以修改实参的值

//值传递
void swap1(int a,int b){
	int tmp=a;
	a=b;
	b=tmp;
}
//地址传递
void swap2(int *p1,int *p2){
	int tmp=*p1;
	*p1=*p2;
	*p2=tmp;
}

指针配合数组、函数案例

void bubbleSort(int* arr, int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				//交换位置
				int tmp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = tmp;
			}
		}
	}
}

void printArr(int * arr,int len) {
	for (int i = 0; i < len - 1; i++) {
		cout << arr[i] << endl;
	}
}

int main() {
	int arr[] = { 4,5,6,3,2,7,8,1,9,10 };
	int len = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr, len);
	printArr(arr, len);
	return 0;
}

结构体

三种创建结构体对象的方式

struct Stu {
	string name;
	int age;
	int score;
}s3;

int main() {
	//第一种方式
	struct Stu s1;
	s1.name = "alex";
	s1.age = 21;
	s1.score = 80;
	cout << s1.name << " " << s1.age << " " << s1.score << endl;

	//第二种方式
	struct Stu s2 = { "jerry",20,90 };
	cout << s2.name << " " << s2.age << " " << s2.score << endl;

	//第三种，当创建结构体时就新建对象
	s3.name = "tom";
	s3.age = 22;
	s3.score = 100;
	cout << s3.name << " " << s3.age << " " << s3.score << endl;

	return 0;
}

结构体数组

	//结构体数组
	struct Stu arr[3] = {
		{"amy",21,70},
		{"bob",23,77},
		{"peter",21,90},
	};
	for (int i = 0; i < 3; i++) {
		cout << arr[i].name << " " << arr[i].age << " " << arr[i].score << endl;

	}

结构体指针

	//结构体指针
	struct Stu s1 = { "kit",23,80 };
	//创建结构体指针p
	Stu* p = &s1;

	cout << p->name << " " << p->age << " " <<p->score << endl;

嵌套结构体

//先要定义内层嵌套的结构体
struct Stu {
	string name;
	int age;
	int score;
}s3;

struct Teacher {
	int id;
	struct Stu stu;
};

int main() {
	struct Stu s1 = { "kit",23,80 };
	struct Teacher t1 = { 1,s1 };
	return 0;
}

结构体作为函数参数

值传递（进行拷贝，修改拷贝不会修改原值）

地址传递

//值传递
void printStuInfo(struct Stu stu) {
	cout << stu.name << " " << stu.age << " " << stu.score << endl;
	return;
}
//地址传递
void printStuInfo1(struct Stu * p) {
	cout << p->name << " " << p->age << " " << p->score << endl;
	return;
}

int main() {
	struct Stu s1 = { "kit",23,80 };
	//值传递
	printStuInfo(s1);
	//地址传递
	printStuInfo1(&s1);
	return 0;
}

取地址&就是取指针！！！

const使用场景

当地址传递时容易出现误操作

//地址传递
void printStuInfo1(const struct Stu * p) {
	//p->age = 3;//此时修改编译器会报错
	cout << p->name << " " << p->age << " " << p->score << endl;
	return;
}