C++:从入门到放弃

旺仔果奶

于 2023-10-30 06:30:28 发布

阅读量942

点赞数 15

分类专栏： C++ 文章标签： c++ 知识图谱

本文链接：https://blog.csdn.net/hzx12e/article/details/134083547

版权

C++ 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

C++基础入门

文章目录

C++基础入门
前言
一、C++初识
二、数据类型
三、运算符
四、程序流程结构
五、函数
六、指针
七、结构体
八、C++核心编程
总结

前言

从文科转到程序狗，为了完成数据结构课程要求，爆肝自学。。

一、C++初识

1.注释
单行注释：//对该行代码说明
多行注释：/* 对该段代码整体说明 */

2.变量
语法：数据类型变量名=初始值；

3.常量
#define 宏常量：#define 常量名常量值；
通常在文件上方定义

const修饰变量：const 数据类型常量名=常量值
在变量定义前加const，该变量不可更改

4.关键字
C++中预先保留的单词或者标识符，有特殊含义

5.标识符命名规则

不能是关键字
只能由字母、数字、下划线组成
第一个字符必须为字母或者下划线
字母区分大小写

二、数据类型

1.整型
整数类型的数据

数据类型	占用空间
short（短整型）	2字节
int（整型）	4字节
long（长整型）	windows4字节，Linux32位4字节，64位8字节
long long	8字节

2.sizeof关键字
统计数据类型所占内存大小
语法：sizeof(数据类型/变量)

3.实型（浮点型）
单精度：float 4字节
双精度：double 8字节

4.字符型
用于显示单个字符
语法：char ch = ‘a’

三、运算符

四、程序流程结构

五、函数

六、指针

1、定义和使用

定义语法：数据类型 * 变量名；

int * p；//区别定义和解引用
p=&a； //让指针记录变量a的地址
p //指针前加* 表示解引用，找到指针指向的内存中的数据

2、指针所占内存

32位：4字节；64位：8字节

3、空指针

定义：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存不可访问

int * p=NULL;

p=100； //报错：0~255之间的内存编号时系统占用的，不能访问

4、野指针

定义：指针变量指向非法内存空间
在程序中避免出现

5、const修饰指针

①const修饰指针：常量指针
②const修饰常量：指针常量
③const又修饰指针又修饰常量

//1、常量指针：指针指向的值不可以改，指针指向可以改
int a=10;
int b=10;
const int * p=&a;
*p=20;  //报错，改了指向的值
p=&b;  //正确
//2、指针常量：指针指向的值可以改，指针指向不可以改
int * const p2=&a;
//3、const修饰指针和常量:指针指向的值和指针指向都不能改
const int * const p3=&a;

6、指针和数组

利用指针访问数组中的元素

int arr[]={1,2,3,4,5,6};
int * p=arr; //指向数组第一个元素

7、指针和函数

作用：指针做函数参数可以修改实参的值

void swap(int *p1,int *p2){
	int temp=*a;
	*a=*b;
	*b=temp;
}//定义的一个函数体
int main(){
	swap(&p1,&p2) //地址传进去，改变实参值
}

七、结构体

1、结构体基本概念

用户自定义的数据类型，允许用户存储不同的数据类型。

2、结构体定义和使用

语法：struct 结构体名 {结构体成员列表}；
创建结构体变量的方式有三种：

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

struct Student{
	String name;
	int age;
	int score;
}s3; //方法三，顺便创建结构体变量
int main(){
	struct Student s1; //方法一
	s1.name="张三";
	struct Student s2={"李四",19,30}; //方法二
	s3.name="王五";

3、结构体数组

作用：将自定义的结构体放入数组中方便维护
语法：struct 结构体名数组名[元素个数] = {{}，{}，{}，…{}}

struct Student{
	String name;
	int age;
	int score;
};
int main(){
	struct Student strArray[3]=
	{
		{"张三",18,100},
		{"李四",28,99},
		{"王五",38,66}
	};
	strArray[2].name="赵六";
}

4、结构体指针

作用：通过结构体指针访问结构体中的成员

struct Student{
	String name;
	int age;
	int score;
};
int main(){
	Student s={"张三",18,100};
	Student *p=&s;  //C++中struct可以省略
	p->name; //指针利用箭头进行访问

5、结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体
例如：每个老师辅导一个学生，老师的结构体中，嵌套一个学生的结构体。

struct student{  //定义学生结构体
	string name;
	int age;
	int score;
};
struct teacher{  //定义老师结构体
	int id;
	string name;
	int age;
	struct student stu;
};
int main(){
	teacher t;
	t.id = 10000;
	t.name = "老王";
	t。stu.name="小王";
}

6、结构体做函数参数

作用：将结构体作为参数向函数传递
传递方式：值传递+地址传递

struct student{  //定义学生结构体
	string name;
	int age;
	int score;
};
void printStudent(struct student s){}
void printStudent1(struct student *p){}
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
int main(){
student s;
	printStudent(s);
	printStudent1(&s); //地址传递，修改形参，实参也改
};

7、结构体中const使用场景

作用：用const防止误操作

//student是结构体变量
void printStudents(const student *s){
	s->age=150; //报错，指针指向的值不能修改，防止误操作
}

八、C++核心编程

1、内存分区模型

内存大方向分为四个区：

代码区：存放函数体的二进制代码，由操作系统进行管理
全局区：存放全局变量和静态变量以及常量
栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
堆区：由程序员分配释放，程序结束时由操作系统回收
不同区的数据生命周期不同，方便灵活编程

1.1 程序运行前

程序编译后，生成exe可执行程序，未执行程序前分为俩个区域
代码区：

存放cpu执行的机器指令
代码区是共享的，对于频繁执行的程序在内存中有一份代码即可
代码区是只读的，防止程序意外修改它的指令

全局区：

全局变量和静态变量存放在此
全局区还包含了常量区，字符串常量和其他常量也存放在此。
该区数据在程序结束之后由操作系统释放

1.2 程序运行后

栈区：

编译器自动分配释放，存放函数的参数值、局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

int* func(int b){ //形参数据也会放到栈区
	b=100;
	int a=10;
	//局部变量放在栈区，栈区数据在函数执行完自动释放
	return &a; //返回局部变量地址（无效）
}

堆区：
由程序猿分配释放，若程序猿不释放，程序结束时由操作系统回收。C++中主要利用new开辟内容。

int * func(){
	//利用new关键字，可以将数据开辟到堆区
	//指针本质也是局部变量，放在栈上，指针保存的数据放在堆区
	int * p=new int(10);
	return p;
}
int main(){
	//在堆区开辟数据
	int *p=func();
	delete p; //释放内存
	//delete[] arr;  //释放数组的指针
}

1.3 new操作符

new操作符在堆区开辟数据，delete操作符释放数据
语法：new 数据类型
利用new创建的数据，会返回该数据对应的类型指针

2、引用

2.1引用的基本使用

作用：给变量起别名
语法：数据类型 &别名 = 原名

int a=10;
int &b=a;  //b和a操作同一块内存

2.2引用注意事项

引用必须初始化
引用在初始化后，不可以改变

int a=10;
int &b=a;	//引用的初始化
//int &b	//错误，必须要初始化
int c=20;
b=c;	//仅仅只是赋值操作

2.3引用做函数参数

作用：函数传参时，利用引用的技术让形参修饰实参
优点：简化指针修改实参

//引用传递
int swap(int &a,int &b){
	int temp=a;
	a=b;
	b=temp;
}
int main(){
	swap(a,b);
}

2.4 引用做函数返回值

作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量引用
用法：函数调用作为左值

int& test(){ //int&表示返回的是引用类型
	static int a=10;
	//静态变量，存放在全局区，全局区上的数据在程序结束后由系统释放
	return a;
}
int main(){
	int &ref=test();
}

2.5 引用的本质

本质：引用的本质在C++内部实现是一个指针常量

int& ref=a;
//自动转换为 int* const ref =&a
//指针常量是指针指向不可改，也说明为什么引用不可更改
ref=20;
//内部发现ref是指针，自动转换为：*ref=20;

2.6 常量引用

作用：常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参

void showValue(const int &val){} //在这个函数里面无法改变val的值

3、函数提高

3.1函数默认参数

函数形参列表中的形参是可以有默认值的
语法：返回值类型函数名（参数=默认值）{}

int func(int a,int b=20,int c=10){}
//如果自己传入数据就用自己的数据，没有就用默认值
//注意事项：
//1、如果某个位置已经有默认参数，从这个位置往后走都必须有默认值
int func2(int a=10,int b,int c){} //报错
//2、如果函数申明有默认参数，函数实现就不能有默认参数
//声明和实现只能有一个有默认参数
int func2(int a = 10,int b = 10);	//函数声明
int func2(int a,int b){}	//函数实现

3.2 函数占位参数

形参列表可以有占位参数，用来占位，调用函数时必须填补该位置
语法：返回值类型函数名（数据类型）{}

void func(int a,int){}
void func1(int a.int =10){}
//占位参数，还可以有默认参数
int main(){
	func(10,10);
	func1(10);
}

3.3 函数重载

3.3.1函数重载概述

作用：函数名可以相同，提高复用性
函数重载满足条件：

同一个作用域下（全局等）
函数名称相同
函数参数类型不同，或者个数不同，或者顺序不同
注意：函数返回值不可以作为函数重载条件

void func(){}
void func(double a){}
void func(int a,double b){}
void func(double a,int b)

3.3.2函数重载注意事项

引用作为重载条件
函数重载碰到函数默认参数

void func(int &a){}
void func(const int &a){}
void func1(int a){}
void func1(int a,int b=10){}
int main(){
	int a=10;
	func(a);	//调用第一个
	func(10);
	//调用第二个，即使没有第二个也不能调用第一个，因为没有指定的内存空间
	func1(10); //非法，出现二义性
}

4、类和对象

C++面向对象三大特性：封装、继承、多态
C++认为万事万物皆为对象，对象上有其属性和行为

4.1封装

4.1.1 封装的意义

封装的意义：

将属性和行为作为一个整体，表现生活中的事务
将属性和行为加以权限控制

访问权限可分为：

公共权限 public 类内可以访问类外可以访问
保护权限 protected 类内可以访问类外不可以访问儿子可以访问
私有权限 private 类内可以访问类外不可以访问儿子不可以访问

class Circle{
	//访问权限
	//公共权限
public:
//类中属性和行为，我们统一称为：成员
	//属性：成员属性、成员变量
	int m_r;
	//行为：成员函数，成员方法
	double calculateZC(){
		return 2*PI*m_r;
	}
};
int main(){
	//通过圆类，创建具体的圆（对象）
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r=10;
}

4.1.2 struct和class的区别

唯一区别在于：默认的访问权限不同
4. struct的默认权限为公共
5. class默认权限为私有

4.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性

	class Person{
	public:
		//姓名设置可读可写
		void setName(string name){
			m_Name = name;
		}
		string getName(){
			return m_Name;
		}
		//获取年龄
		int getAge(){
			return m_Age;
		}
		//设置年龄
		void setAge(int age){
			if(age<0||age>150){
				m_Age=0;
				cout <<"你个妖精！"<<endl;
			}
			m_Age=age;
		}
	private:
		string m_Name;	//可读可写
		int m_Age;	//可读可写，但是输入范围有要求
	}	
	int main(){
		Person p;
		p.setName("张三");
		p.setAge(100);	
	}

4.2 对象的初始化和清理

4.2.1构造函数和析构函数

对象的初始化和清理是非常重要的安全问题
构造函数和析构函数会被编译器自动调用，完成初始化和清理操作
我们不提供构造和析构，编译器会提供
编译器提供的构造和析构函数是空实现
构造函数：创造对象时为成员属性赋值
析构函数：对象销毁前自动调用

构造函数语法：类名(){}

没有返回值也不写void
函数名称与类名称相同
构造函数可以有参数，因此可以发生重载
程序在调用对象的时候会自动调用构造，无需手动调用，而且只会调用一次

析构函数语法：~类名(){}

没有返回值，也不写void
函数名称与类名相同，在名称前加~
析构函数不可以有参数，因此不可以发生重载
程序在对象销毁前会自动调用析构，无须手动调用，并且只会调用一次

4.2.2 构造函数的分类及调用

俩种分类方式：

按参数分类：有参构造和无参构造
按类型分类：普通构造和拷贝构造

三种调用方式：

括号法
显示法
隐式转换法

class Person{
public:
	Person(){}		//无参构造
	Person(int a){}		//单参构造
	Person(const Person &p){} //拷贝构造函数
	//将传入人身上的所有属性拷贝到我身上且不能修改
}
//调用
void test(){
	//1、括号法
	Person p1;	//默认构造函数调用
	Person p2(10);	//有参构造函数
	Person p3(p2);	//拷贝构造函数
	//注意：
	//调用默认构造函数不加（）
	Person p1();	//编译器会认为是一个函数声明
	//2、显示法
	Person p1;
	Person p2 = Person((10);	//有参构造
	Person p3 = Person(p2);		//拷贝构造
	Person(10);		//匿名对象，特点：当前执行结束后，系统马上回收掉匿名对象
	//不要利用拷贝构造函数初始化匿名对象。
	//编译器认为Person(p3)==Person p3，可能与以往定义有冲突
	//3、隐式转换法
	Person p4=10;	//相当于Person p4=Person(10) 有参构造
	Person p5=p4;	//拷贝构造
}

4.2.3 拷贝构造函数调用时机

使用一个已经创建完毕的对象来初始化一个新对象
值传递的时候给函数参数传值
以值方式返回局部对象

class Person{
public:
	Person(){}
	Person(int age){}
	Person(const Person & p){}
	~person(){}
	int Age;
}
//1、使用一个已经创建完毕的对象来初始化一个新对象
void test1(){
	Person p1(20);
	Person p2(p1);
}
//2、值传递的方式给函数参数传值
void doWork(Person p){}
void test2(){
	Person p;
	doWork(p); //调用函数时，实参传给形参，调用拷贝构造函数
}
//3、值方式返回局部对象
Person doWork2(){
	Person p1;
	return p1;
}
void test3(){
	Person p=doWork2();
	//调用拷贝构造函数
}

4.2.4 构造函数调用规则

默认情况下编译器至少给一个类添加3个函数

默认构造函数（无参，函数体为空）
默认析构函数（无参，函数体为空）
默认拷贝构造函数，对属性进行值拷贝

构造函数的调用规则如下：

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造。此时调用默认构造函数会报错
如果用户定义拷贝构造函数，c++不会提供其他构造函数，调用其他构造函数会报错。

4.2.5 深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的坑
浅拷贝：简单的复制拷贝操作
深拷贝：在地区重新申请空间，进行拷贝操作
如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。

class Person{
public:
	//无参（默认）构造函数
	Person(){}
	//有参构造函数
	Person(int age,int height){
		m_age=age;
		m_height=new int(height);
		//new创造的数据，返回该数据对应的指针
	}
	//拷贝构造函数
	Person(const Person& p){
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age=p.m_age;
		m_height = new int(*p.m_height);
		//m_height=p.m_height
		//默认情况下浅拷贝，拷贝前后指向同一个堆，出现重复释放问题
	}
	//析构函数
	~Person(){
		//堆内存的地址不为空
		if(m_height!=NULL){
		//释放其指向的堆区内存
			delete m_height;
			n_height=NULL;
		}
	}
public:
	int m_age;
	int* m_height;
	//new开辟堆内存，返回指针
};

4.2.6 初始化列表

作用：c++提供初始化列表语法，用来初始化属性
语法：构造函数():属性1(值1),属性2(值2)…{}

//Person类里面
Person(int a,int b,int c) :m_A(a),m_B(b),m_C(c){}

4.2.7 类对象作为类成员

类成员可以是另一个类的对象，我们称为对象成员
先构造A，再构造B ; 先析构B，再析构A

class A{}
class B{
	A a;
}

4.2.8 静态成员

在成员变量和成员函数之前加上关键字static

静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量

class Person{
public:
	//类内声明
	static int m_A;
	static void func(){
		m_A=100; //静态成员函数可以访问静态成员变量
		//m_C=200;  //报错，静态成员函数不能访问非静态成员变量
		//因为非静态成员不是全局的变量，不同的对象调用静态方法时无法区分是哪个对象的非静态成员
		cout << "static void func调用" <<endl;
	}
	int m_C;
	//静态成员变量也是有访问权限的
private:
	static int m_B;
};
//类外初始化，并说明是类Person下的静态成员
int Person::m_A = 100;
int Person::m_B = 200;
void test{
	//1、通过对象访问
	Person p;
	cout<< p.m_A<<endl;
	p.func();
	//2、通过类名访问
	cout <<Person::m_A<< endl;
	Person::func();
	//3、一个地方更改，全部访问时都更改
	Person p1;
	p1.m_A=200;
	//4、静态成员变量也是有访问权限的
	//cout <<Person::m_B<< endl; //类外访问不到私有的静态成员变量和私有的静态成员函数
}

4.3C++对象模型和this指针

4.3.1 成员变量和成员函数分开存储

c++编译器会给每个空对象也分配一个字节空间，为了区分空对象占内存的位置。
成员变量和成员函数分开存储。
非静态成员变量，属于类的对象。静态成员变量和非静态成员函数都不属于类的对象上。

4.3.2 this指针概念

每个非静态成员函数只会诞生一份函数实例，多个同类型的对象会共用一块代码。
这一块代码通过this指针区分调用自己的对象。this指针指向被调用成员函数所属的对象。
this指针隐含在非静态成员函数内，不需要定义直接使用
this指针的用途：

当形参和成员变量同名，用this指针来区分
在类的非静态成员函数中返回对象本身，可使用return *this

class Person{
public:
	Person(int age){
	//1、解决名称冲突
		this->age=age;
	}
	//引用的方式做一个返回
	Person& PersonAddAge(Person &p){
		this->age+=p.age;
		//2、this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}
	int age;
}
void test(){
	Person p1(10);
	Person p2(10);
	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
}

4.3.3 空指针访问成员函数

c++中空指针也可以调用成员函数，但是要注意有没有用到this指针
用到this指针，要加以判断保证代码健壮性

class Person{
public:
	void showClassName(){
		cout << "this is a Person class"<< endl;
	}
	void showPersonAge(){
		cout << "age=" << m_Age << endl;
	}
	//m_Age实际上是this->m_Age，当传入空指针时，this没有指向确切的数据，因此会报错

//正确写法：
//	void showPersonAge(){
//		if(this==NULL){
//			return;
//		}
		cout << "age=" << m_Age << endl;
	}
	int m_Age;
};
void test(){
	Person * p=NULL;
	p->shouClassName();
	//p->showPersonAge(); //报错，实际上用到this指针
}

4.3.4 const修饰成员函数

常函数：

成员函数后加const，称为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数

class Person{
	public:
	//this指针的本质，是指针常量，指针的指向不能修改
	//在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
	void showPerson() const{
		this->m_B = 100; //不会报错
		//this->m_A = 100;
		//this = NULL; //this指针不可以修改指针指向
	}
	void func(){}
	int m_A;
	mutable int m_B; //特殊变量，即使在常函数中，也可以修改这个值
	}
void test(){
	const Person p; //在对象前加const，变为常对象
	//p.m_A=100; //报错，无法修改
	p.m_B = 100; //m_B是特殊值，在常对象下也可以修改
	//常对象只能调用常函数
	p.showPerson();
	//p.func(); //报错，因为普通成员函数可以修改属性
}

4.4 友元

有些私有的属性，想要类外特殊的一些函数或者类进行访问，需要用到友元技术
友元目的：让一个函数或者类访问另一个类中的私有成员，友元关键字为friend

友元的三种实现：

全局函数做友元
类做友元
成员函数做友元

4.4.1 全局函数做友元

class Building{
	//告诉编译器，goodGay全局函数是Buildong类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building *building) //类似于函数声明
public:
	Building(){
		this->m_SettingRoom="客厅";
		this->m_BedRoom="卧室";
	}
public:
	string m_SettingRoom:
private:
	string m_BedRoom;
};
void goodGay(Building *building){
	cout << "好基友正在访问："<< building->m_SettingRoom << endl;
	cout << "好基友正在访问："<< building->m_BedRoom <<endl; //能够访问私有成员属性
}

4.4.2 类做友元

class GoodGay{};
class Building{
	//GoodGay类是本类的好朋友，可以访问本类私有成员属性
	friend class GoodGay;
public:
	Building();
	void visit();
};
//在类外定义函数的方法：
Building::Building(){} //类名称::成员函数名(){}
//上式没有返回值类型，是因为这是无参构造函数
void Building::visit(){}

4.4.3 成员函数做友元

class GoodGay{
public:
	GoodGay(){}
	void visit(){}
}
class Building{
	//告诉编译器，GoodGay类下的visit成员函数作为本类好朋友，可以访问私有成员
	friend void GoodGay::visit();
public:
	Building(){};
}

4.5 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

4.5.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

//加号运算符重载
class Person{
public:
	//1、通过成员函数重载+号
	Person operator+(Person &p){
		Person temp;
		temp.m_A=this->m_A+p.m_A;
		temp.m_B=this->m_B+p.m_B;
		return temp;
	}
	int m_A;
	int m_B;
};
//2、全局函数重载+号
Person operator+(Person &p1,Person &p2){
	Person temp;
	temp.m_A=p1.m_A+p2.m_A;
	temp.m_B=p1.m_B+p2.m_B;
	return temp;
}
//运算符重载也可以发生函数重载
Person operator+(Person &p1, int num){...}
//调用
void test(){
	Person p1;
	p1.m_A=10;
	p1.m_B=10;
	Person p2;
	p2.m_A=10;
	p2.m_B=10;
	//成员函数重载本质调用
	Person p3=p1.operator+(p2);
	//全局函数重载的本质调用
	Person p3=operator+(p1,p2);
	//俩个重载方法二选一
	Person p3=p1+p2;
	//运算符重载也可以发生函数重载
	Person p3=p1+100; //Person + int
}

总结1：内置的数据类型的表达式的运算符是不可能改变的
总结2：不要滥用运算符重载

4.5.2 左移运算符重载

作用：可以输出自定义数据类型

//1、利用成员函数重载 左移运算符。p.operator<<(cout) 简化版本:p << cout
//不能利用成员函数重载<<运算符，因为无法实现cout在左侧
//void operator<<(cout){}
//只能用全局函数重载左移运算符
ostream & operator<<(ostream &out,Person &p){
	out << "m_A="<<p.m_A<<"m_B="<<p.m_B;
	return out;
} //输出时可以输出对象p的所有成员属性（m_A、m_B）
void test(){
	//调用时直接调用对象名
	cout << Person << endl;
}

4.5.3 递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据

	//1、利用成员函数重载前置++运算符，返回引用是为了一直对一个数据进行递增操作
	//以下函数在MyInteger类内部
	MyInteger& operator++(){
		//先对成员属性做++运算
		m_Num++;
		//再将自身做返回
		return *this;
	}
	//2、重置后置++运算符
	//void operator++(int)	int代表占位符，可以用于区分前置和后置递增
	MyInteger operator++(int){
		//先 记录当时结果
		MyInteger temp = *this;
		//后 递增
		m_Num++;
		//最后将记录结果做返回
		//前置递增返回的是引用，后置递增返回的是值
		//因为局部变量不能返回引用，非法操作
		return temp;
	}

4.5.4 赋值运算符重载

c++编译器至少给一个类添加4个函数

默认构造函数（）{}
默认析构函数（）{}
默认拷贝构造函数，对属性值进行拷贝
赋值运算符operator=，对属性进行值拷贝
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝的问题。

Person& operator=(Person &p){
	//编译器提供浅拷贝
	//m_Age = p.m_Age;

	//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
	if(m_Age!=NULL){
		delete m_Age;
		m_Age=NULL;
	}
	//深拷贝
	m_Age = new int(*p.m_Age);
	//返回对象本身
	return *this;
}

4.5.5 关系运算符重载

作用：重置关系运算符，可以让俩个自定义类型对象进行对比操作

//重载==号
bool operator==(Person & p){
	//把对象属性进行逐个比较
	if(this->m_Name == p.m_Name && this->m_Age == p.m_Age){
		return true;
	}else{
		return flase
	}
}

4.5.6 函数调用运算符重载

函数调用运算符（）也可以重载
游族重载后使用的方式非常像函数的调用，因此称为仿函数
仿函数没有固定写法，非常灵活

class MyPrint{
	//重载函数调用运算符
	void operator()(string test){
		cout << test <<endl;
	}
};
void test1(){
	MyPrint myPrint;
	myPrint("hello world");
	//由于使用起来非常类似于函数调用，因此称为仿函数
}
//仿函数使用非常灵活
class MyAdd{
public:
	int operator()(int num1,int num2){
		return num1+num2;
	}
};
void test2(){
	MyAdd myadd;
	int ret=myadd(100,100);
	//匿名函数对象
	cout << MyAdd()(100,100)<< endl;
}

4.6 继承

继承是面向对象三大特性之一
有些类与类之间存在特殊关系，继承的技术可以减少重复代码

4.6.1 继承的基本语法

class A{}
class B:public A{
public:
	xxx;	
}

4.6.2 继承方式

继承的语法：class 子类：继承方式父类
继承方式一共有三种：公共继承、保护继承和私有继承
区别不同的继承方式

4.6.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？
父类中的所有非静态成员属性都会被子类继承下去
父类中的私有成员属性，是被编译器给隐藏了，因此是访问不到，但确实被继承下去了

4.6.4 继承中构造和析构顺序

子类继承父类之后，当创建子类对象，也会调用父类的构造函数
先构造父类，再构造子类；先析构子类，再析构父类

4.6.5 继承同名成员处理方式

当子类和父类出现同名的成员，如何通过子类对象进行访问
访问子类同名成员：直接访问即可；访问父类同名成员：需要加作用域

//假设已经定义了子类和父类
//1、同名成员属性的处理方式
void test(){
	Son s;
	cout <<"Son 下m_A=" << s.m_A << endl;
	cout <<"Base 下m_A=" << s.Base::m_A << endl;
}
//2、同名成员函数的处理方式
void test1(){
	Son s;
	s.func();
	s.Base::func();
	//父类函数重载时同样只需要加作用域
	s.Base::func(100);
}

4.6.6 继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象中如何访问

静态成员和非静态成员出现同名，处理方式一致：

访问子类同名成员，直接访问即可
访问父类同名成员，需要加作用域

//1、通过对象访问
s.Base::m_A;
s.Base::func();
//2、通过类名访问
Son::m_A;
Base::m_A; 
//Son::Base::m_A: 和上面相同
Base::func(); 
//Son::Base::func();
//第一个::代表通过类名方式访问，第二个::代表访问父类作用域

4.6.7 多继承语法

c++允许一个类继承多个类
语法：class 子类：继承方式父类1，继承方式父类2…
多继承可能引发父类中有同名成员出现，需要加作用域区分，实际开发中不建议多继承

class son:public base1,public base2{
public:
	xxx;
}

4.6.8 菱形继承

菱形继承概念：

两个派生类继承同一个基类
又有某个类同时继承这两个派生类
这种继承被称为菱形继承，或者钻石继承

菱形继承问题：

羊继承了动物的数据，驼同样继承动物的数据，当草泥马使用数据时，会产生二义性
草泥马继承自动物的数据继承了俩份，但我们只需要一份就可以

//利用虚继承解决菱形继承的问题
//继承之前，加上关键字virtual变为虚继承
//animal类为虚基类
class sheep : virtual public Animal{};
class Tuo:virtual public Animal{};
//继承的是一个指针vbtable：visual base table，指针加上特有的偏移量，形成唯一数据

4.7 多态

4.7.1 多态的基本概念

多态是C++面向对象三大特性之一，多态分为俩类：

静态多态：函数重载和运算符重载，复用函数名
动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态的区别：

静态多态的函数地址早绑定：编译阶段确定函数地址
动态多态的函数地址晚绑定：运行阶段确定函数地址

//动态多态满足条件
//1、有继承关系	2、子类重写父类的虚函数		3、父类的指针或者引用指向子类对象
class Animal{
public:
	//虚函数
	virtual void speak(){};
};
class Cat:public Animal{
public:
	//重写：函数返回值类型，函数名，参数列表完全相同，virtual关键字可写可不写
	void speak(){};
};
class Dog:public Animal{
public:
	void speak(){};
};
//没加virtual关键字时，执行说话函数：地址早绑定，在编译阶段确定函数地址，test执行的时候只会调用Animal中speak函数
//如果想在test中让猫说话，就不能函数地址提前绑定，需要在运行阶段进行绑定，用virtual关键字地址晚绑定
void doSpeak(Animal &animal){ //Animal & animal = cat;
	animal.speak();
}
void test(){
	Cat cat;
	doSpeak(cat); //父类指针或者指向执行子类对象
}

4.7.3 纯虚函数和抽象类

多态中通常父类虚函数的实现是毫无意义的（不会被调用到），主要调用子类重写的内容，可以将虚函数改为纯虚函数
纯虚函数语法：victual 返回值类型函数名 {参数列表} =0 ；当类中有纯虚函数，这个类也叫做抽象类

抽象类特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类，无法实例化对象

//纯虚函数和抽象类
class Base{
public:
	//纯虚函数，抽象类
	virtual void func()=0;
};
class Son:public Base{
public:
	virtual void func(){};
};

4.7.5 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区（前提条件），那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象的问题
都需要具体的函数实现（需要有大括号的意思）

虚析构与纯虚析构的区别：如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构语法：virtual ~类名(){}
纯虚析构语法：virtual ~类名() =0;

class Animal{
public:
	void Animal(){};
	//纯虚析构，需要声明也需要实现
	virtual ~Animal()=0;
};
Animal::~Animal(){}

5、文件操作

程序运行时产生的数据是临时数据，程序一旦运行结束都会被释放，通过文件可以将数据持久化
c++中对文件操作需要包含头文件，文件类型分为两种：

文本文件：文件以文本的ASCII码形式存储在计算机中
二进制文件：文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂他们

操作文件的三大类：1、ofstream：写操作 2、ifstream：读操作 3、fstream：读写操作

5.1 文本文件

5.1.1 写文件

写文件的步骤如下：
1、包含头文件（#include）2、创建流对象（ofstream ofs;） 3、打开文件（ofs.open(“文件路径”,打开方式);） 4、写数据（ofs <<“写入的数据”;） 5、关闭文件（ofs.close();）

注意：文件打开方式可以配合使用，利用 | 操作符
例如：用二进制方式写文件 ios::binary | ios::out

#include<iostream>
using namespace std;
#include <fstream> //头文件包含
void test(){
	ofstream ofs;	//创建流对象
	ofs.open("test.txt",ios::out);	//指定打开方式，test.txt是文件名，如果没有此文件则创建同名新文件
	ofs <<"姓名：张三"<<endl;		//写内容
	ofs.close();	//关闭文件
}

5.1.2 读文件

读文件步骤如下：
1、包含头文件（#include） 2、创建流对象（ifstream ifs;） 3、打开文件并判断文件是否打开成功（ifs.open(“文件路径”,打开方式);） 4、读数据（四种方式读取） 5、关闭文件（ifs.close();）

#include<iostream>
using namespace std;
#include <fstream> //头文件包含
#include <string>
void test(){
	ifstream ifs;	//创建流对象
	ifs.open("test.txt",ios::in);	//指定打开方式
	if(!ifs.is_open()){
		cout<<"文件打开失败"<<endl;
		return;
	}
	//读数据第一种方法：
	char buf[1024] = {0}; //初始化字符数组
	while(ifs>>buf){
		cout<<buf<<endl;
	}
	//读数据第二种方法：
	char buf[1024] = {0}; //初始化字符数组
	while(ifs.getline(buf.sizeof(buf))){	
	//getline表示逐行把数据放入指针buf指向的数组中，sizeof(buf)代表最多读多少数据
		cout<<buf<<endl;
	}
	//读数据的第三种方法：
	string buf;
	while(getline(ifs,buf)){
	//getline(a,b)，a表示基础的输入流对象，b表示准备的字符串
		cout<<buf<<endl;
	}
	//读数据的第四种方法：不推荐，因为逐个读没有逐行读快
	char c;
	while((c = ifs.get())!=EOF){ //EOF end of file
		cout << c;
	}
	ifs.close();	//关闭文件
}

5.2 二进制文件

以二进制方式对文件进行读写操作，打开方式要指定为 ios::binary

5.2.1 写文件

二进制写文件主要利用流对象调用成员函数write
函数原型：ostream& write(const char * buffer, int len);
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数

#include<iostream>
using namespace std;
#include<fstream>
//二进制文件，写文件。可以写入自定义数据类型
class Person{
public:
	char m_Name[64];	//姓名
	int m_Age;	//年龄
};
void test(){
	ofstream ofs;	//创建流对象
	//ofstream ofs("person.txt",ios::out|ios::binary); //结合创建流对象和打开文件
	ofs.open("person.txt",ios::out|ios::binary);	//打开文件
	Person p = {"张三",18};	//写文件
	ofs.write((const char *)&p,sizeof(Person));	//把Person类型强转为const char*
	ofs.close();
}

5.2.2 读文件

二进制读文件主要利用流对象调用成员函数read
函数原型：istream& read(char * buffer, int len);
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数

#include<iostream>
using namespace std;
#include<fstream>
//二进制文件 读文件
class Person{
public:
	char m_Name[64];	//姓名
	int m_Age;	//年龄
};
void test(){
	ifstream ifs;
	ifs.open("person.txt",ios::in|ios::binary);
	if(!ifs.is_open()){	//打开文件，判断是否打开成功
		cout<<"文件打开失败"<<endl;
		return;
	}
	Person p;	//读文件
	ifs.read((char *)&p,sizeof(Person));
	cout <<"姓名："<< p.m_Name << "年龄"<<p.m_Age<<endl;
	ifs.close();
}

总结

模板、STL、string容器、vector容器、deque容器、stack容器、queue容器、list容器、set容器、map容器、谓词、内建函数对象、常用算法等知识点随缘更新，敬请期待！！

旺仔果奶

关注

15
点赞
踩
29

收藏

觉得还不错? 一键收藏
1
评论
C++:从入门到放弃

从文科转到程序狗，为了完成数据结构课程要求，爆肝自学。。定义语法：数据类型 * 变量名；int * p；//区别定义和解引用p=&a；//让指针记录变量a的地址p //指针前加* 表示解引用，找到指针指向的内存中的数据语法：struct 结构体名 {结构体成员列表}；struct结构体名变量名struct 结构体名变量名={成员1值，成员2值…}定义结构体时顺便创建变量int age;int score;}s3;//方法三，顺便创建结构体变量//方法一。
复制链接

扫一扫