-
-
[原创]C++学习 待删 不会传图片
-
发表于: 2023-5-3 21:24
-
C++的诞生
Bjarne Stroustrup 1983
C++的特性
const 的新用法
C++的const是真的常量，可以用于设置数组的长度
const常见的用法
1. 定义常量: const int PI = 3.14;
2. 用作修饰函数的参数，确保不被修改，参考strstr
3. 函数返回一个常量。
4. 修饰当前对象的内容不能被修改。int get() const;
引用类型
引用类型的定义: 类型 & 引用名称 = 被引用对象;
引用和指针的关系
引用必须初始化，非常量指针不用初始化。
引用一经初始化，不能指向其它变量。非常量指针可以。
使用引用可以直接访问被引用对象，指针需要通过(*)间接的访问。
在实现上，引用和指针完全相同，推荐使用引用。
函数的重载
函数重载的目的：静态联编多态
通过一个函数名称可以传入不同的参数调用不同的函数
函数重载的要求
int show(int);
1. 函数的名称及作用域相同
2. 函数的参数个数不同
int show(int, double);
3. 函数的参数类型不同
int show(double);
4. 函数的参数顺序不同
int show(double, int);
5. 函数的返回值不是函数重载的要求之一
void show(int); 不可以
函数的默认参数
声明函数的默认参数
1. 当只存在函数定义的时候，直接写在函数定义中
2. 当同时存在定义和声明的时候，只能写在其中的一个中，推荐写在声明中。
使用默认参数的要求
1. 默认参数的顺序必须是从右到左不能断开
C++中堆的使用(new/delete)
申请堆空间: new / new[]
释放堆空间 delete / delete[]
C语言和C++中使用堆的区别
1. new/delete会调用构造和析构，但是malloc/free 不会调用
2. new 的单位是元素个数new int[15]; ，malloc的单位是字节malloc(sizeof(int) * 15)
3. new 的返回值是类型的指针，但是malloc的返回值是void*
4. new/delete是运算符(关键字)，malloc和free是库函数
new/delete的底层实现通常都是 malloc/free
C++中的类型转换
static_cast：静态类型转换
const_cast: 常量转换
reinterpret_cast : 通常用于指针间的转换
dynamic_cast：用于父类指针和子类指针之间的转换
输入输出
使用输入函数 iostream
std::cin >> 变量1 >> 变量2;
(std::cin.operator>>(变量1)).operator>>(变量2);
使用输出函数 iostream
std::cout << 变量1 << 变量2 << std::endl << std::ends;
格式化输出数据 iomanip
setfill: 设置填充数据
setw: 设置宽度
hex: 十六进制显示
推荐使用printf格式化输出
内存分区模型
c++程序在执行的时候,将内存分为4个区域
代码区:存放函数体的二进制代码,由操作系统进行管理
全局区:存放全局变量和静态变量以及常量
栈区:由编译器自动分配释放,存放函数的的参数值,局部变量等
堆区:有程序员分配和释放,若程序员不释放,程序结束时由操作系统回收
他们的意义:
不同区域存放的数据,赋予不同的生命周期,给我们更大的灵活编程;
程序运行前
在程序编译前,生成exe可执行程序,未执行该程序分为两个区域
代码区
存放cpu执行的机器指令
代码区是共享的,共享的目的是对于频繁被执行的程序,只需要在内存中有一份代码即可
代码区是只读的,使其只读的原因是防止程序意外的修改它的指令
全局区
全局变量和静态变量以及常量存放在此
全局区还包含了常量区,字符串常量和其他常量也存放在此
该区域的数据在程序结束之后由操作系统回收
#include<iostream>
using namespace std;
//c_ const g_global l_ local
//全局变量
int g_a = 10;
int g_b = 10;
//const修饰的全局变量(全局常量)
const int c_g_a = 10;
const int c_g_b = 10;
int main(){
int a = 10;
int b = 10;
const int c_l_a = 10;
const int c_l_b = 10;
cout << "局部变量a的地址为: " << (int)&a << endl;
cout << "局部变量b的地址为: " << (int)&b << endl;
cout << "全局变量g_a的地址为: " << (int)&g_a << endl;
cout << "全局变量g_b的地址为: " << (int)&g_b << endl;
//静态变量
static int s_a = 10;
static int s_b = 10;
cout << "静态变s_a的地址为: " << (int)&s_b << endl;
cout << "静态变量s_b的地址为: " << (int)&s_a << endl;
//常量
//字符串常量
cout << "字符串常量的地址: " << (int)&"hello word" << endl;
//const修饰的变量
//const修饰的全局变量
cout << "全局常量c_g_a的地址: " << (int)&c_g_a << endl;
cout << "全局常量c_g_b的地址: " << (int)&c_g_b << endl;
//const修饰的局部常量
cout << "局部常量c_l_a的地址: " << (int)&c_l_a << endl;
cout << "局部常量c_l_b的地址: " << (int)&c_l_b << endl;
return 0;
}
总结
- C++程序运行前分为全局区和代码区
- 代码区的特点是共享和只读
- 全局区中存放的是全局变量、静态变量、常量
- 常量区中川航的cosnt修饰的全局常量 和 字符串常量
栈区
由编译器自动分配释放,存放函数的参数值,局部变量
不要返回局部变量的地址,栈区开辟的数据由编译器自动释放
堆区
由程序员分配释放，若程序员不释放，程序结束时由操作系统系统回收。
new操作符
C++中利用new操作符在堆区开辟数据
堆区开辟数据,由程序员手动开辟,手动释放,释放利用操作符 delete
语法
new 数据类型
利用new创建数据,会返回该数据对应的类型的指针
代码示例
#include<iostream>
using namespace std;
//1.new的基本用法
int* func()
{
//在堆区创建整型数据
//new返回的是该数据类型的指针
int *p=new int(10);
return p;
}
void test01()
{
//堆区的数据由程序员管理释放
int* p = func();
cout << *p << endl;
//利用delete释放
delete p;
//cout << *p << endl; //内存已经被释放 再次使用就是非法操作
}
//2.在堆区利用new开辟数组
void test02()
{
//创建10个整型数据的数组在堆区
int*parr=new int[10];
for (int i = 0; i < 10; i++)
{
parr[i] = i+100;
}
for (int i = 0; i < 10; i++)
{
pcout << arr[i] << endl;
}
//释放数组的时候要加[]
delete[] parr;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}new delete malloc free 区别
1.malloc和free是函数 new和 delete是C++的运算符;
2.malloc返回的是viod*指针,需要我们自己强制转换,new申请声明类型,就是什么类型的指针
3.malloc不会调用类的构造函数 free不会调用类的析构函数,new会调用构造,delete会调用析构
引用
引用的注意事项
- 引用必须初始化
- 引用在初始化之后不可以改变
- 、
引用做函数参数
作用:函数传参时,可以利用引用的技术让形参修饰实参
优点:可以简化指针修改实参
引用做函数返回值
作用:应用是可以作为函数返回值存在的
注意:不要返回局部变量引用
用法:函数调用作为左值
引用的本质
引用其实就是指针常量
编译器发现是引用,
转换成int*const ref=&a;
引用一旦初始化,就不可以发生改变,指针常量是指针指向不可改,也说明了指针为什么不可以更改
指针常量(指针是常量( 常量指针(常量的指针
指针常量:该指针是一个常量是一个指向不可以更改值可以更改的指针
常量指针:指向常量的指针,是一个指向可以更改值不可以更改的指针
指针常量: int *const cp_a+&a
常量指针:const int *p_ca=&a;
常量引用
作用:常量引用主要用来修饰形参,防止误操作
在函数形参列表中,可以加const修饰形参,防止形参改变实参
const int&ref=10;
加上const 之后,编译器将代码需改为 int temp=10,const int &ref=temp;
假如函数之后 const 变为只读,不可以修改;
函数提高
在c++中,函数的形参列表中的形参是可以有默认值的,
语法:返回值类型函数名 (参数=默认值){}
屏幕剪辑的捕获时间: 2022/7/16 16:23
屏幕剪辑的捕获时间: 2022/7/16 16:24
如果我们自己传入数据,就用自己数据,如果没有就使用默认值
注意事项
如果某个位置已经有了默认参数那么从这个位置以后,从左向右都必须有默认值
屏幕剪辑的捕获时间: 2022/7/16 16:26
默认实参不在形参列表的结尾
如果函数的声明有了默认参数,那么这个函数实现就不能有默认参数
声明和实现只能有一个有默认参数
屏幕剪辑的捕获时间: 2022/7/16 16:31
屏幕剪辑的捕获时间: 2022/7/16 16:31
这样会有二义性
函数占位参数
c++中的函数形参列表可以有占位参数,用作占位,调用函数时候必须要填补位置
语法:返回值类型函数名 (数据类型) {}
屏幕剪辑的捕获时间: 2022/7/16 16:36
目前来说占位参数还用不到,后面的课程会用到这个参数
占位参数,还可以有默认参数
函数重载
函数重载概述
作用函数名相同提高复用性
函数重载满足的条件
- 同一个作用域下
- 函数名称相同
- 函数参数类型不同,或者个数不同或者顺序不同
注意:函数的返回值不可以作为函数重载的条件
函数重载的好处
1.不需要维护很多的函数名使用起来就比较方便
有一个专业的名词接口复用 函数重载是一种多态机制
函数重载语法得益于一种名称粉碎机制的支持,
名称粉碎机制
屏幕剪辑的捕获时间: 2022/7/16 16:51
屏幕剪辑的捕获时间: 2022/7/16 18:23
函数重载注意事项
- 引用作为重载条件
- 函数重载碰到默认参数
屏幕剪辑的捕获时间: 2022/7/16 19:11
屏幕剪辑的捕获时间: 2022/7/16 19:11
上图假如常量10进入 void func(int&a) 这个函数
也就成为int &a=10
我们说引用必须有一个合法的内存空间
但是常量10存放在常量区这显然是不合法的
如果const int &a=10; 这是合法的代码
函数重载碰到默认参数
屏幕剪辑的捕获时间: 2022/7/16 19:17
屏幕剪辑的捕获时间: 2022/7/16 19:20
这时func(10)进行调用的时候出现了二义性,编译器不知道该进入那个函数
类和对象
C++面向对象(构件导向)的三大特性
封装.继承.多态
C++认为万事万物都皆为对象,对象上有其属性和行为
例如:
人可以作为对象,属性有姓名,年龄,身高,体重….行为有走,跑,跳,唱歌,吃饭
车也可以作为对象,属性有轮胎,方向盘,车灯行为有载人.放空调,放音乐
具有相同性质的对象,我们可以抽象为类
人属于人类车属于车类
封装
封装是C++面对对象三大特性之一
封装的意义
- 将属性和行为作为一个整体,表现生活中的事务
- 将属性和行为加以权限控制
封装的意义1:
在设计类的时候,属性和行为写在一起,表现事务
语法:class 类名{ 访问权限:属性 / 行为 };
示例1:
设计一个圆类,求圆的周长
作业
设计一个学生类
属性有姓名和学号
可以给姓名和学号赋值,可以显示学生的姓名和学号
/*
设计一个学生类
属性有姓名和学号
可以给姓名和学号赋值,可以显示学生的姓名和学号
*/
class Student
{
public:
int m_Id;
string m_Name;
void showStudent()
{
cout << "姓名: " << m_Name << " 学号: " << m_Id << endl;
}
};
int main()
{
Student s1;
s1.m_Name = "张三";
s1.m_Id = 1;
s1.showStudent();
Student s2;
system("pause");
return 0;
}
结构体和类的区别
在C++中除了类中可以有构造函数和析构函数外，结构体中也可以包含构造函数和析构函数，这是因为结构体和类基本雷同，唯一区别是，类中成员变量默认为私有，而结构体中则为公有。注意，C++中的结构体是可以有析构函数和构造函数，而C则不允许。至于联合体，它是不可能有析构函数和构造函数的。本质上，它是一种内存覆盖技术的体现，也就是说，同一块内存在不同的时刻存储不同的值（可能是不同类型的）。
C语言中的结构体
（1）由于C语言是面向过程的，所以C中的结构体就不存在面向对象的任何特点：不能继承；不能封装；不能多态；不存在访问控制，只有作用域。
（2）C语言中的结构体只能定义数据，而不能定义方法，虽然C语言的结构体中不能定义函数，但是却可以定义函数指针，不过函数指针本质上不是函数而是指针。
（3）C语言中的结构体不能为空，否则会报错。定义一个结构体的变量时，结构体名前的struct关键字不能省略，否则会报错。
c++ 结构体和类的区别
而struct和class之间最本质的一个区别就是默认的访问控制： struct默认的数据访问控制是public的，而class默认的成员变量访问控制是private的。
C++结构体的初始化
结构体是常用的自定义构造类型，是一种很常见的数据打包方法。结构体对象的初始化有多种方式，分为**顺序初始化**、**指定初始化**、**构造函数初始化**。假如有如下结构体。
struct A{
int b;
int c;
};
（1）顺序初始化因为书写起来较为简约，是我们最常用的初始化方式，但相对于指定初始化，无法变更数据成员初始化顺序，灵活性较差，而且表现形式不直观，不能一眼看出 struct 各个数据成员的值。
A a = {1, 2};
（2）指定初始化（Designated Initializer）实现上有两种方式，一种是通过点号加赋值符号实现，即“.fieldname=value”，另外一种是通过冒号实现，即“fieldname:value”，其中 fieldname 为结构体成员名称 。前者是 C99 标准引入的初始化方式，后者是 GCC 的扩展。遗憾的是有些编译器并不支持指定初始化，比如 Visual C++。
// 点号+赋值符号
A a = {.b = 1, .c = 2};
//冒号
A a = {b:1, c:2};
Linux 内核喜欢用 .fieldname=value 的方式进行初始化，使用指定初始化，一个明显的优点是成员初始化顺序和个数可变，并且扩展性好，比如在结构体非末尾处增加字段时，避免了传统顺序初始化带来的大量修改。
（3）构造函数初始化常见于 C++ 代码中，因为 C++ 中的 struct 可以看作 class，结构体也可以拥有构造函数，所以我们可以通过结构体的构造函数来初始化结构体对象。给定带有构造函数的结构体：
struct A{
A(int a,int b){
this->a=a;
this->b=b;
};
int b;
int c;
}
那么结构体对象的初始化可以像类对象的初始化那样，如下形式：
注意： struct 如果定义了构造函数的话，就不能用大括号进行初始化了，即不能再使用指定初始化与顺序初始化了。
2.结构体赋值
变量的赋值和初始化是不一样的，初始化是在变量定义的时候完成的，是属于变量定义的一部分，赋值是在变量定义完成之后想改变变量值的时候所采取的操作。还是给定结构体 A：
struct A {
int b;
int c;
};
注意： 结构体变量的赋值是不能采用大括号的方式进行赋值的，例如下面的赋值是不允许的。
A a;
a={1,2}; // 错误赋值
下面列出常见结构体变量赋值的方法。
（1）使用 memset 对结构体变量进行置空操作：
按照编译器默认的方式进行初始化（如果 a 是全局静态存储区的变量，默认初始化为0，如果是栈上的局部变量，默认初始化为随机值）
A a;
memset(&a,0,sizeof(a));
（2）依次给每一个结构体成员变量进行赋值：
A a;
a.b=1;
a.c=2;
（3）使用已有的结构体变量给另一个结构体变量赋值。也就是说结构体变量之间是可以相互赋值的。
A a={1,2};
struct A a1;
a1=a; // 将已有的结构体变量赋给a1
初始化与赋值有着本质的区别，初始化是变量定义时的第一次赋值，赋值则是定义之后的值的变更操作，概念上不同，所以实现上也不一样。
类的权限
类在设计时,可以把属性和行为放在不同的权限下,加以控制
访问权限有三种
- public 公共权限 可以通过类的对象去直接使用的成员
- protected 保护权限 不可以通过类的对象直接去使用的成员
- private 私有权限 不可以通过类的对象直接去使用的成员
权限的设定体现了面向对象的封装思想
通常都是将数据定义为私有的这样的话使用类的人就不能随意的修改数据,只能通过类的函数来用这些数据.
更为安全一些
理解this指针
this指针代表的就是自己。
CStuInfo stu1; 请问这个对象占用多少个字节呢？？？占用28个字节。
当我们定义对象的时候，只是定义了数据部分。
每一个对象，都有自己的数据。
同一个类的所有对象，都是共用代码的。代码只有1份。
在同一份代码中怎么去区分该使用那个数据就是通过this指针来区别的
一个对象的this指针并不是对象本身的一部分，不会影响 sizeof （对象）的结果。 this 作用域 是在类内部，当在类的非静态 成员函数 中访问类的非静态成员的时候， 编译器 会自动将对象本身的地址作为一个隐含 参数传递 给函数。
对象的**初始化和清理**也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
c++利用了**构造函数**和**析构函数**解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此如果**我们不提供构造和析构，编译器会提供**
**编译器提供的构造函数和析构函数是空实现。**
* 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
* 析构函数：主要作用在于对象**销毁前**系统自动调用，执行一些清理工作。
**构造函数语法：**`类名(){}`
1. 构造函数，没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
**析构函数语法：** `~类名(){}`
1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同,在名称前加上符号 ~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
转换构造函数语法
// 转换构造函数.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
//复数类
class Complex {
public:
Complex() : m_real(0.0), m_imag(0.0) { }
Complex(double real, double imag) : m_real(real), m_imag(imag) { }
Complex(double real) : m_real(real), m_imag(0.0) { } //转换构造函数
public:
friend ostream & operator<<(ostream &out, Complex &c); //友元函数
private:
double m_real; //实部
double m_imag; //虚部
};
//重载>>运算符
ostream & operator<<(ostream &out, Complex &c) {
out << c.m_real << " + " << c.m_imag << "i";;
return out;
}
int main() {
Complex a(10.0, 20.0);
cout << a << endl;
a = 25.5; //调用转换构造函数
cout << a << endl;
return 0;
}构造函数分类和调用
两种分类方式：
按参数分为： 有参构造和无参构造(默认构造)
按类型分为： 普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
构造函数
在对象被创建后,会自动调用
全局对象
局部对象
堆中的对象
假如有一个类是 CStudent
CStudent* p = new CStudent[5]; //这样会调用5个构造函数
CStudent* p2= (CStudent*)malloc(sizeof(CStudent)*5);//malloc不会调用构造函数
构造函数的名字和类名是一致的
构造函数没有返回值,可以有参数是可以重载的,一个类中有多个构造函数
析构函数
在对象被销毁的时候,会自动的调用
全局对象程序结束的是否自动销毁
局部对象离开作用域的时候销毁
堆中对象释放的时候会自动销毁
匿名对象离开当前行会销毁
函数的参数如果是类对象等同于局部对象离开作用域的时候也需要调用析构函数
析构函数没有返回值也没参数,不能重载一个类只能有一个析构函数
class Person {
public:
//无参（默认）构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
public:
int age;
};
总结
Person p1(10);
调用无参构造函数不能加括号，如果加了编译器认为这就是一个函数声明。不会认为是在创建对象Person p2();
显示法：
Person p2 = Person(10);
Person p3 = Person(p2);
person（10）；单独写就是匿名对象，当前行结束之后，系统会自动回收匿名对象，马上析构。
隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
拷贝构造的调用时机
- 使用一个已经创建完毕的对象来初始化一个新的对象。
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
//1. 使用一个已经创建完毕的对象来初始化一个新对象
Person man(100); //p对象已经创建完毕
Person newman(man); //调用拷贝构造函数
Person newman2 = man; //拷贝构造
//Person newman3;
//newman3 = man; //不是调用拷贝构造函数，赋值操作
//2. 值传递的方式给函数参数传值
在值传递的时候,会临时的生成一个临时的副本
//3. 以值方式返回局部对象
构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
* 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
* 如果用户定义拷贝构造函数，c++不会再提供其他构造函数
深拷贝和浅拷贝
浅拷贝： 简单的赋值拷贝操作
深拷贝： 在堆区重新申请空间，进行拷贝操作。memcpy strcpy _strdup
如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
为什么要使用深拷贝
我们希望在改变新的对象的时候，不改变原来的对象。
浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存（分支）。
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。
如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象，是“值”而不是“引用”（不是分支）
拷贝第一层级的对象属性或数组元素
递归拷贝所有层级的对象属性和数组元素
深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。
浅拷贝和赋值的区别
当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容，因此，两个对象是联动的。
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制资源。
初始化列表
C++提供了初始化列表语法，用来初始化属性
**语法：**`构造函数()：属性1(值1),属性2（值2）... {}`
//传统方式初始化
Person(int a, int b, int c) {m_A = a;m_B = b;m_C = c;}
//初始化列表方式初始化
Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
类对象作为类成员
//当类中成员是其他类对象时，我们称该成员为 对象成员
//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
//析构顺序与构造相反
静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
* 静态成员变量
* 所有对象共享同一份数据
* 在编译阶段分配内存
* 类内声明，类外初始化
* 静态成员函数
* 所有对象共享同一个函数
* 静态成员函数只能访问静态成员变量
静态数据成员之所以不计算在类的对象大小内，是因为类的静态数据成员被该类所有的对象所共享，并不属于具体哪个对象，静态数据成员定义在内存的全局区
成员变量和成员函数分开存储
在C++中，类内的成员变量和成员函数分开存储。
只有非静态成员变量才属于类的对象上。
C++编译器会给每一个空对象也分配1字节内存。
空指针访问成员函数
```C++
//空指针访问成员函数
class Person {
public:
void ShowClassName() {
cout << "我是Person类!" << endl;
}
void ShowPerson() {
if (this == NULL) {
return;
}
cout << mAge << endl;
}
public:
int mAge;
};
void test01()
{
Person * p = NULL;
p->ShowClassName(); //空指针，可以调用成员函数
p->ShowPerson(); //但是如果成员函数中用到了this指针，就不可以了
}const 修饰成员函数 -- 常函数
* 成员函数后加const后我们称为这个函数为**常函数**
* 常函数内不可以修改成员属性
* 成员属性声明时加关键字mutable后，在常函数中依然可以修改
**常对象：**
* 声明对象前加const称该对象为常对象
* 常对象只能调用常函数
1、指针常量——指针类型的常量（int *const p）
本质上一个常量，指针用来说明常量的类型，表示该常量是一个指针类型的常量。在指针常量中，指针自身的值是一个常量，不可改变，始终指向同一个地址。在定义的同时必须初始化。
来自 <https://blog.csdn.net/weixin_52244492/article/details/124081709>
2、常量指针——指向“常量”的指针（const int *p， int const *p）
常量指针本质上是一个指针，常量表示指针指向的内容，说明该指针指向一个“常量”。在常量指针中，指针指向的内容是不可改变的，指针看起来好像指向了一个常量。
// C++_Study.cpp : 定义控制台应用程序的入口点。
//
/*
*/
#include "stdafx.h"
#include <iostream>
using namespace std;
class Person {
public:
Person() {
m_A = 0;
m_B = 0;
}
//this指针的本质是一个指针常量，指针的指向不可修改
//如果想让指针指向的值也不可以修改，需要声明常函数
void ShowPerson() const {
//const Type* const pointer;
//this = NULL; //不能修改指针的指向 Person* const this;
//this->mA = 100; //但是this指针指向的对象的数据是可以修改的
//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
this->m_B = 100;
}
void MyFunc() const {
//mA = 10000;
}
public:
int m_A;
mutable int m_B; //可修改 可变的
};
//const修饰对象 常对象
void test01() {
printf("类sizeof %d \r\n", sizeof(Person));
const Person person; //常量对象
cout << person.m_A << endl;
//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
//常对象访问成员函数
person.MyFunc(); //常对象不能调用const的函数
}
int main() {
test01();
system("pause");
return 0;
}友元
生活中你的家有客厅(Public)，有你的卧室(Private)
客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去
但是呢，你也可以允许你的好闺蜜好基友进去。
在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
友元的目的就是让一个函数或者类 访问另一个类中私有成员
友元的三种实现
* 全局函数做友元
* 类做友元
* 成员函数做友元
#### 4.4.1 全局函数做友元
```C++
class Building
{
//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
friend void goodGay(Building * building);
public:
Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom; //卧室
};
void goodGay(Building * building)
{
cout << "好基友正在访问： " << building->m_SittingRoom << endl;
cout << "好基友正在访问： " << building->m_BedRoom << endl;
}
void test01()
{
Building b;
goodGay(&b);
}
int main(){
test01();
system("pause");
return 0;
}#### 4.4.2 类做友元
```C++
class Building;
class goodGay
{
public:
goodGay();
void visit();
private:
Building *building;
};
class Building
{
//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
friend class goodGay;
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
building = new Building;
}
void goodGay::visit()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit();
}
int main(){
test01();
system("pause");
return 0;
}
```#### 4.4.3 成员函数做友元
```C++
class Building;
class goodGay
{
public:
goodGay();
void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
void visit2();
private:
Building *building;
};
class Building
{
//告诉编译器 goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
friend void goodGay::visit();
public:
Building();
public:
string m_SittingRoom; //客厅
private:
string m_BedRoom;//卧室
};
Building::Building()
{
this->m_SittingRoom = "客厅";
this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
building = new Building;
}
void goodGay::visit()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void goodGay::visit2()
{
cout << "好基友正在访问" << building->m_SittingRoom << endl;
//cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01()
{
goodGay gg;
gg.visit();
}
int main(){
test01();
system("pause");
return 0;
}
```运算符重载
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
加号运算符重载
#include "stdafx.h"
//> 总结1：对于内置的数据类型的表达式的的运算符是不可能改变的
//> 总结2：不要滥用运算符重载
class Person
{
public:
Person() {};
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
//成员函数实现 + 运算符重载
//Person operator+(const 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;
};
//全局函数
Person operator+(const Person&p1, const 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+(const Person& p2, int val)
{
Person temp;
temp.m_A = p2.m_A + val;
temp.m_B = p2.m_B + val;
return temp;
};
void test()
{
Person p1(10u, 10u);
Person p2(20u, 20u);
Person p3 = p1 + p2;
p3 = p1 + 10u;
}
int main()
{
test();
system("pause");
return 0;
}左移运算符重载
#include "stdafx.h"
#include <iostream>
using namespace std;
class Person
{
friend ostream& operator<<(ostream& out, Person& p);
public:
Person() {};
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
int m_A;
int m_B;
};
ostream& operator<<(ostream& out, Person& p)
{
out << "a:" << p.m_A << " b:" << p.m_B;
return out;
}
void test()
{
Person p1(10u, 10u);
Person p2(20u, 20u);
cout << p1 << "hello world" << endl; //链式编程
}
int main()
{
test();
return 0;
}递增运算符重载
#include "stdafx.h"
#include <iostream>
using namespace std;
class MyInteger {
friend ostream& operator<<(ostream& out, MyInteger myint);
public:
MyInteger() {
m_Num = 0;
}
//前置++
MyInteger& operator++() {
//先++
m_Num++;
//再返回
return *this;
}
//后置++
MyInteger operator++(int) {
//先返回
MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
m_Num++;
return temp;
}
private:
int m_Num;
};
ostream& operator<<(ostream& out, MyInteger myint) {
out << myint.m_Num;
return out;
}
//前置++ 先++ 再返回
void test01() {
MyInteger myInt;
cout << ++myInt << endl;
cout << myInt << endl;
}
//后置++ 先返回 再++
void test02() {
MyInteger myInt;
cout << myInt++ << endl;
cout << myInt << endl;
}
int main()
{
test02();
test01();
return 0;
}赋值运算符重载
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题
// 赋值运算符重载.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
using std::cout;
using std::endl;
class Person
{
public:
Person(int age);
~Person();
Person& operator=(Person & p)
{
if (m_Age!=NULL)
{
delete m_Age;
m_Age = NULL;
}
//提供深拷贝
m_Age = new int(*p.m_Age);
return *this;
}
int * m_Age;
};
Person::Person(int age)
{
m_Age = new int(age);
}
Person::~Person()
{
if (m_Age!=NULL)
{
delete m_Age;
m_Age = NULL;
}
}
int main()
{
Person p1(18);
Person p2(20);
Person p3(30);
p3 = p2 = p1; //赋值操作
cout << "p1的年龄为：" << *p1.m_Age << endl;
cout << "p2的年龄为：" << *p2.m_Age << endl;
cout << "p3的年龄为：" << *p3.m_Age << endl;
p3 = Person(19);//这里格外注意 当不提供自定义运算符 进行深拷贝 会导致double free
return 0;
}关系运算符重载
重载关系运算符，可以让两个自定义对象进行对比操作
// 关系运算符重载.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <string.h>
using namespace std;
class Person
{
public:
Person();
Person(string name,int age);
~Person();
public:
string m_Name;
int m_Age;
bool operator==(Person & p)
{
if (this->m_Age==p.m_Age&&
this->m_Name==p.m_Name)
{
return true;
}
else
{
return false;
}
}
bool operator!=(Person & p)
{
if (this->m_Age == p.m_Age&&
this->m_Name == p.m_Name)
{
return false;
}
else
{
return true;
}
}
};
Person::Person()
{
}
Person::Person(string name, int age)
{
this->m_Name = name;
this->m_Age =age;
}
Person::~Person()
{
}
int main()
{
Person p1("小明",18);
Person p2("小李", 19);
Person p3("小明", 18);
if (p1==p2)
{
printf("p1 p2相等");
}
else
{
printf("p1 p2 不相等");
}
if (p1!=p3)
{
printf("p1 p3 不相等");
}
else
{
printf("p1 p3 相等");
}
return 0;
}函数调用运算符（）重载
由于重载后使用的函数非常像函数的调用，因此称之为仿函数
// 函数调用运算符重载.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <string.h>
using std::string;
using std::cout;
using std::endl;
class MyPrint
{
public:
void operator()(string text)
{
printf("%s", text.c_str());
}
};
void test01()
{
//重载的（）操作符 也称为仿函数
MyPrint myFunc;
myFunc("hello world");
}
class MyAdd
{
public:
int operator()(int v1, int v2)
{
return v1 + v2;
}
};
void test02()
{
MyAdd add;
int ret = add(10, 10);
cout << "ret = " << ret << endl;
//匿名对象调用
cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}继承
**继承是面向对象三大特性之一**
我们发现，定义这些类时，下级别的成员除了拥有上 ------
这个时候我们就可以考虑利用继承的技术，减少重复代码。
继承的好处：==可以减少重复的代码==
class A : public B;
A 类称为子类 或 派生类
B 类称为父类 或 基类
**派生类中的成员，包含两大部分**
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性。
继承的方式
继承中的对象模型
#### 4.6.3 继承中的对象模型
**问题：**从父类继承过来的成员，哪些属于子类对象中？
// 1. 继承中的对象模型.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};
//公共继承
class Son :public Base
{
public:
int m_D;
};
void test01()
{
cout << "sizeof Son = " << sizeof(Son) << endl;
}
int main() {
test01();
system("pause");
return 0;
}cl /d1 reportSingleClassLayoutSon "1. 继承中的对象模型.cpp"
继承中构造析构的顺序
> 总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反；
当具有类对象成员和父类的时候：
1,构造顺序是父类成员自己
2,析构顺序是自己成员父类
当具有多个成员中构造顺序和定义顺序一样和初始化列表顺序无关
继承中同名成员处理方式
问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？
* 访问子类同名成员 直接访问即可
* 访问父类同名成员 需要加作用域
1. 子类对象可以直接访问到子类中同名成员
2. 子类对象加作用域可以访问到父类同名成员
3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。
// 2. 继承中同名成员处理方式.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base {
public:
Base()
{
m_A = 100;
}
void func()
{
cout << "Base - func()调用" << endl;
}
void func(int a)
{
cout << "Base - func(int a)调用" << endl;
}
public:
int m_A;
};
class Son : public Base {
public:
Son()
{
m_A = 200;
}
//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
void func()
{
cout << "Son - func()调用" << endl;
}
public:
int m_A;
};
void test01()
{
Son s;
cout << "Son下的m_A = " << s.m_A << endl;
cout << "Base下的m_A = " << s.Base::m_A << endl;
s.func();
s.Base::func();
s.Base::func(10);
}
int main() {
test01();
system("pause");
return EXIT_SUCCESS;
}问题：继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
> 总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）；
多继承语法
语法：` class 子类 ：继承方式 父类1 ， 继承方式 父类2...`
多继承可能会引发父类中有同名成员出现，需要加作用域区分
// 3. 多继承.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
class Base1 {
public:
Base1()
{
m_A = 100;
}
public:
int m_A;
};
class Base2 {
public:
Base2()
{
m_A = 200; //开始是m_B 不会出问题，但是改为mA就会出现不明确
}
public:
int m_A;
};
//语法：class 子类：继承方式 父类1 ，继承方式 父类2
class Son : public Base2, public Base1
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
public:
int m_C;
int m_D;
};
//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
Son s;
cout << "sizeof Son = " << sizeof(s) << endl;
cout << s.Base1::m_A << endl;
cout << s.Base2::m_A << endl;
}
int main() {
test01();
system("pause");
return 0;
}菱形继承
**菱形继承概念：**
两个派生类继承同一个基类
又有某个类同时继承者两个派生类
这种继承被称为菱形继承，或者钻石继承
1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。
// 4. 菱形继承.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
class Animal
{
public:
int m_Age;
};
//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};
void test01()
{
SheepTuo st;
st.Sheep::m_Age = 100;
st.Tuo::m_Age = 200;
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
cout << "st.m_Age = " << st.m_Age << endl;
}
int main() {
test01();
system("pause");
return 0;
}
多态
**多态是C++面向对象三大特性之一**
多态分为两类
* 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名
* 动态多态: 派生类和虚函数实现运行时多态
静态多态和动态多态区别：
* 静态多态的函数地址早绑定 - 编译阶段确定函数地址
* 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
// 4. 多态.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
using namespace std;
class Animal
{
public:
//Speak函数就是虚函数
//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
void speak()
{
cout << "动物在说话" << endl;
}
};
class Cat :public Animal
{
public:
void speak()
{
cout << "小猫在说话" << endl;
}
};
class Dog :public Animal
{
public:
void speak()
{
cout << "小狗在说话" << endl;
}
};
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编
void DoSpeak(Animal & animal)
{
animal.speak();
}
//
//多态满足条件：
//1、有继承关系
//2、子类重写父类中的虚函数
//多态使用：
//父类指针或引用指向子类对象
void test01()
{
Cat cat;
cat.speak();
Animal* p=NULL;
p->speak();
Dog dog;
DoSpeak(dog);
}
int main() {
test01();
system("pause");
return 0;
}虚函数的用处
多态:不同的主体对于同样的指令做出不同的应答:
构造函数不能是虚函数
析构函数可以是虚函数
析构函数是虚函数，有一定的用处。
当我们在继承关系中，使用到了虚函数，那么此时，我们应该将析构函数，也定义为虚函数。
这样当我们delete 父类指针的时候，子类对象也会被析构
纯虚函数和抽象类
父类为了管理子类对象，需要一个虚函数，但是父类中又没有好的虚函数的实现方式，这个时候，我们可以将父类中的这种函数实现为 纯虚函数
包含纯虚函数的类，我们称之为 抽象类 。抽象类不能创建对象。
子类中应该实现父类中的纯虚函数。如果没有实现纯虚函数，那么子类也是抽象类。
抽象类不能定义对象，可以定义指针
模板技术 泛型编程
模板的使用：模板用于实现类型不同但是逻辑相同的类和函数
template [class | typename]
class 和 typename 没有区别
函数模板的使用
函数的寻找优先级: 普通函数 > 模板函数 > 特化函数
函数模板和模板函数:
函数模板：是一个模板，不会生成具体的代码，只提供逻辑
模板函数：当一个函数模板被使用的时候，会检查参数，并根据传入的参数实例化出一个模板函数，模板函数会生成实际的代码；
函数模板有全特化，但是没有偏特化，函数模板的偏特化就是函数的重载。
类模板的使用
类模板可以全特化也可以偏特化
1. 全特化就是特化所有的类型
2. 偏特化就是特化部分的类型
类模板的实现和定义必须要放在同一个文件，否则会报错
当在类模板外实现函数时，需要重新的指定模板关键字和参数
template <typename T>
void swap(T& a,T& b)
{
T nTemp = a;
a = b;
n = nTemp;
}
模板技术的基本原理：
我们提供模板（代码的逻辑）。
编译器根据模板和参数类型，自己去创造函数。创造出来的函数 称之为 模板函数
我们自己写的叫 函数模板
// 类模板.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
template <typename T>
class CData
{
public:
void SetData(T data)
{
m_data = data;
}
T GetData()
{
return m_data;
}
private:
T m_data;
};
int main()
{
CData<int> obj_int;
obj_int.SetData(20);
printf("%d \n", obj_int.GetData());
CData<double> obj_double;
obj_double.SetData(20.0);
printf("%f", obj_double.GetData());
return 0;
}重载 重写和 重定义
重载
作用域不同 参数不同 名称相同
重写 override
作用域不同 必须存在虚函数 参数和返回值需要一致
重定义
作用域不同 参数可以相同也可以不相同 之类的同名函数会隐藏父类的函数
[注意]传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！
|
|
|---|---|
