一、内存分区模型
c++ 程序在执行时,将内存大方向划为4 个区域
- 代码区:存放函数的二进制代码,由操作系统进行管理的
- 全局区:存放全局变量和静态变量以及常量,字符串常量,const 修饰变量
- 栈区:由编译器自动分配释放,存放函数的参数值,局部变量等 不要返回局部变量的地址
- 堆区:由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收
内存四区的意义:不同区域存放的数据,赋予不同的生命周期,给我们更大的灵活编程
//栈区
int* func()
{
int a = 10;
return &a;
}
int main()
{
int *p = func();//接受func函数的返回值
cout << *p << endl;//第一次可以打印,编译器做了保留
cout << *p << endl;//第二次这个数据就不在保留了
return 0;
}
//堆区
int* func()
{
int* a = new int(10);//申请内存空间
return a;
}
int main()
{
int* p = func();
cout << *p << endl;
delete p;//释放堆区的数据
}
二、引用
作用:给变量起别名
语法:数据类型 &别名 = 原名;
注意事项:
- 引用必须初始化
- 引用在初始化后,不可以改变
本质:引用的本质在C++内部实现是一个指针常量
自动转化为 int *const ref = &a; 指针常量是指针指向不可改,也说明为什么引用不可更改
常量引用,防止误操作 const int &a = ref;//只能读不能写
//引用作为函数的参数
void swap(int &a, int &b)
{
int temp;
temp = a;
a = b;
b = temp;
return;
}
int main()
{
int a = 10;
int &b = a;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
b = 100;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("system");
return 0;
}
引用可以作为函数的返回值存在的
注意:不要返回局部变量引用
用法:函数调用作为左值
int& test01()
{
int a = 10;//局部变量
return a;
}
//返回静态变量引用
int& test02()
{
static int a = 20;
return a;
}
三、函数的提高
在C++中,函数的形参列表中的形参是可以有默认值的
语法: 返回值类型 函数名( 参数 = 默认值 ) {}
示例:
//1、如果某个位置参数有默认值,那么从这个位置往后,从左向右,必须都要有默认值
//2、声明、实现只能有一个默认参数(防止产生二义性)
int func(int a, int b = 10);
int func(int a, int b)
{
return a + b;
}
函数的占位参数
语法: 返回值类型 函数名(数据类型){}
调用的时候,必须传入对应的数据类型的数据
//函数的占位参数,可以是默认采纳数
void func(int a, int)
{
cout << "this is func" << endl;
}
函数重载
作用:函数名可以相同,提高复用性
满足条件:
- 同一个作用域下
- 函数名称相同
- 函数参数类型不同 或者 个数不同 或者 顺序不同
注意:函数的返回值不可以作为函数重载的条件
注意事项:
1、引用作为重载的条件
void func(int& a)
{
cout << "func(int& a)调用" << endl;
}
void func(const int& a)
{
cout << "func(const int& a)调用" << endl;
}
int main()
{
int a = 10;
func(a);// int& a = 10;// 不合法
func(10);// const int& a = 10; //合法
system("pause");
return 0;
}
2、函数重载碰到默认参数
void func(int a, int b = 10)
{
cout << "func(int a, int b = 10)调用" << endl;
}
void func(int a)
{
cout << "func(int a)调用" << endl;
}
int main()
{
int a = 10;
func(a);// 会产生二义性
system("pause");
return 0;
}
四、类和对象
C++ 面向对象的三大特性为:封装,继承,多态
封装
封装的意义:
- 将属性和行为作为一个整体,表现生活中的事物
- 将属性和行为加以权限控制
优点1:将所有成员属性设置为私有,可以自己控制读写权限
优点2:对于写权限,我们可以检测数据的有效性
派生类
子类 public 类内可以访问 类外可以访问 派生类可以访问
protected 类内可以访问 类外不可以访问 派生类可以访问
private 类内可以访问 类外不可以访问 派生类不可以访问
语法:
class 类名
{
访问权限:
属性/行为
};
示例1:设计一个圆类,求圆的周长
const double PI = 3.14;
class Circle
{
public:
double calculate()
{
return 2 * PI * m_r;
}
public:
double m_r;
};
int main()
{
Circle c1;//通过圆类 创建具体的圆
c1.m_r = 10;//给圆的属性赋值
cout << c1.calculate() << endl;//方法
return 0;
}
在C++ 中struct 和 class 唯一区别就在于 默认的访问权限不同
struct 默认权限是公共的, 而class 默认权限是私有的
对象初始化和清理
构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无需手动调用。
构造函数语法: 类名(){}
- 构造函数,没有返回值也不写void
- 函数名称与类名相同
- 构造函数可以有参数,因此可以发生重载
- 程序在调用对象时候会自动调用构造,无须手动调用,而且只会调用一次
析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作。
析构函数语法: ~类名(){}
- 析构函数,没有返回值也不写void
- 函数名称与类名相同,在名称前加上符号~
- 构造函数不可以有参数,因此不可以发生重载
- 程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次
//调用默认构造函数时候,不要加()
//因为下面这行代码,编译器会认为是一个函数的声明
Person p1();
//显示法
Person p1;
Person p2 = Person(10);//有参构造
Person p3 = Person(p3);//拷贝构造
Person(10);//匿名对象 特点:当前执行结束后,系统会立即回收掉匿名对象
//不要利用拷贝构造函数,初始化匿名对象
Person(p3);// 编译器会认为 Person(p3) == Person p3;
//隐式装换
Person p4 = 10; // 相当于写了 Person p4 = Person(10);//有参构造
Person p5 = p4; // 拷贝构造
拷贝构造函数调用时机
三种情况:
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
class Person
{
public:
Person()
{
cout << "Person 默认构造函数调用" << endl;
}
Person(int age)
{
m_Age = age;
cout << "Person 有参构造函数调用" << endl;
}
Person(const Person& p)
{
m_Age = p.mAge;
cout << "Person 拷贝构造函数调用" << endl;
}
~Person()
{
cout << "Person 析构函数调用" << endl;
}
private:
int m_Age;
};
如果我们写了有参构造函数,编译器就不再提供默认构造,依然提供拷贝构造
如果我们写了拷贝构造函数,编译器不会再提供其他构造函数
深拷贝与浅拷贝
深拷贝:在堆区重新申请空间,进行拷贝操作
浅拷贝:简单的赋值拷贝操作
class Person
{
public:
Person()
{
cout << "Person 默认构造函数调用" << endl;
}
Person(int age, int height)
{
m_Age = age;
m_Height = new int(height);
cout << "Person 有参构造函数调用" << endl;
}
Person(const Person& p)
{
m_Age = p.mAge;
m_Height = new int (*p.m_Height);
cout << "Person 拷贝构造函数调用" << endl;
}
~Person()
{
//将堆区开辟的数据做释放操作
if(NULL != m_Height)
{
delete m_Height;
m_Height = NULL;
}
cout << "Person 析构函数调用" << endl;
}
private:
int m_Age;
int* m_Height;
};
int main()
{
Person p1(18, 160);
Person p2(p1);//浅拷贝带来的问题是堆区的内存重复释放
return 0;
}
初始化列表
作用:C++ 提供了初始化列表语法,用来初始化属性
语法: 构造函数(): 属性1(值1),属性2(值2)…{}
class Person
{
public:
//传统初始化操作
Person(int a, int b)
{
m_A = a;
m_B = b;
}
//初始化列表
Person(int a, int b):m_A(a), m_B(b)
{
}
int m_A;
int m_B;
};
当其他类对象作为本类成员,构造时候先构造类对象,再构造自身,析构的顺序也构造相反
静态成员
静态成员就是在成员变量和成员函数前加上关键static, 称为静态成员
静态成员分为:
-
静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明、类外初始化 -
静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
class Person
{
public:
static void func();
static int m_A;
};
int Person::m_A = 0;
调用:
1、通过对象访问
Person p;
p.func();
2、通过类名访问
Person::func();
成员函数和成员变量是分开存储的
class Person
{
};
void test01()
{
Person p;
//空对象占内存空间为:1
//C++ 编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
//每一个空对象也应该有一个独一无二的内存地址
return;
}
this 指针的概念
每一个非静态成员函数只会诞生一份函数实例,也就是说多个同类型的对象会共用一个块diamante
那么问题是:这一块代码是如何区分哪个对象调用自己的呢?
C++ 通过提供特殊的对象指针,this 指针,解决上述问题,this 指针指向被调用的成员函数所属的对象
this 指针是隐含每一个非静态成员内的一种指针
this 指针不需要定义,直接使用即可
this 的用途:
- 当形参和成员变量同名时,可用this 指针区分
- 在类的非静态成员函数中返回对象本身,可使用return *this
Person& PersonAddAge()
{
this->age += p.age;
//this 指向p2 的指针,而*this 指向的就是p2 这个对象本体
return *this;
}
空指针访问成员函数
C++ 中空指针也是可以调用成员函数的,但是也要注意有没有用到this 指针
如果用到this 指针,需要加以判断保证代码的健壮性
class Person
{
public:
void ShowClassName()
{
cout << "Person类" << endl;
}
void ShowPerson()
{
if(this == NULL)
{
return;
}
}
};
void test01()
{
Person* p = NULL;
p->showClassName();
p->ShowPerson();
}
const 修饰成员函数
常函数:
- 成员函数后加const 后我们称这个函数为常函数
- 常函数内不可以修改成员属性
- 成员属性声明时加关键字mutable 后,在常函数中依然可以修改
常对象:
- 声明对象前加const 称该对象
- 常对象只能调用常函数
class Person
{
public:
void showPerson() const
{
m_B = 100;
//m_A = 100;//报错 ,this 指针的本质是指针常量 指针的指向是不允许修改的
}
int m_A;
mutable int m_B;
};
友元
- 全局函数做友元
- 类做友元
- 成员函数做友元
class Building;
class GoodGay
{
public:
GoodGay()
{
building = new Building;
}
void visit();
Building* building;
};
class Building
{
friend class GoodGay;
public:
string m_SittingRoom;
Building()
{
m_SittingRoom = "客厅";
m_BedRoom = "卧室";
}
private:
string m_BedRoom;
};
void GoodGay::visit()
{
cout << "building->m_SittingRoom:" << building->m_SittingRoom << endl;
cout << "building->m_BedRoom:" << building->m_BedRoom << endl;//由于声明了友元类,所以可以访问私有成员
}
void test01()
{
GoodGay gg;
gg.visit();
}
运算符重载
运算符重载的定义:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
class Person
{
public:
Person(){}
Person(int a, int b)
{
this->m_A = a;
this->m_B = b;
}
Person operator+(const Person& p)
{
this->m_A = this->m_A + p.m_A;
this->m_B = this->m_B + p.m_B;
return *this;
}
private:
int m_A;
int m_B;
};
总结:对于内置的数据类型的表达式运算符是 不可能改变的
总结:不要滥用运算符重载
//左移运算符重载
//只能利用全局函数左移重载, 不然调用就是 p << cout
ostream& operator<< (ostream& cout, Person& p)//operator<< (cout , p) => cout << p
{
cout << p.m_A;
return cout;
}
运算符小括号() 重载
由于重载后使用的方式非常像函数的调用,因此称为仿函数
class MyPrint
{
public:
void operator()(string text)
{
cout << text << endl;
}
};
void test01()
{
MyPrint myFunc;
myFunc("hello world");
}
继承
优点:解决复用性(减少重复代码)
语法: class 子类 : 继承方式 父类
子类: 派生类
父类: 基类
继承过来的表现其共性,新增的成员体现其个性
class BasePage
{
public:
void Header()
{
cout << "首页" << endl;
}
void Footer()
{
cout << "底部" << endl;
}
void Left()
{
cout << "列表" << endl;
}
};
class Java : public BasePage
{
void Content()
{
cout << "JAVA 学习视频" << endl;
}
};
查看对象模型:
开发人员命令提示符
cd 跳转至具体的路径
cl /dl reportSingleClassLayoutSon “03 继承中的对象模型.cpp”
继承中的构造函数和析构顺序如下:
先构造父类,再构造子类,析构的顺序与构造的顺序相反
当子类与父类拥有同名的成员函数,子类会隐藏父类中同名函数,加作用域可以访问到父类中同名函数
问题:当子类与父类出现同名的成员,如何通过子类对象,访问到子类或者父类中同名的函数?
访问子类同名成员 直接访问
访问父类同名成员 需要加作用域
class Base
{
public:
Base()
{
m_A = 100;
}
int m_A;
};
class Son
{
public:
Son()
{
m_A = 200;
}
int m_A;
}
int main()
{
Son s1;
cout << s1.m_A << endl;
cout << s1.Base::m_A << endl;
}
菱形继承
概念:两个派生类继承同一个类,又有某个类同时继承两个派生类,这种继承被称为菱形继承或者砖石继承
问题:
1、羊继承了动物的数据,坨同样继承了动物的数据,当草泥马使用数据时,就会产生二义性
2、草泥马继承来自动物的数据继承了两份,其实我们应该清楚,这份数据我们只需要一份就可以。
//虚继承
class Animal
{
public:
int m_Age;
};
class Sheep : virtual public Animal
{
};
//利用虚继承 解决菱形继承的问题
class Tuo : virtual public Animal
{
};
class SheepTuo : public Sheep, public Tuo
{
};
int main()
{
SheepTuo st;
//st.m_Age = 18;//会产生二义性
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 28;//当菱形继承,两个父类拥有相同数据,需要加以作用域区分
//这份数据我们知道 只有一份就可以,菱形继承导致继承数据有两份,资源浪费
return 0;
}
多态
多态分为两类:
静态多态:函数重载和运算符重载
动态多态:派生类和虚函数实现运行时多态
静态多态的函数地址早绑定,编译阶段确定函数地址
动态多态的函数地址晚绑定,运行阶段确定函数地址
动态多态使用:
父类指针或者引用,执行子类对象
//早绑定
class Animal
{
public:
void speak()
{
cout << "Animal Speak" << endl;
}
};
class Cat : public Animal
{
void speak()
{
cout << "Cat Speak" << endl;
}
};
int main()
{
Cat cat;
Animal& animal = cat;
animal.speak();
}
//晚绑定
class Animal
{
public:
virtual void speak()
{
cout << "Animal Speak" << endl;
}
};
class Cat : public Animal
{
void speak()
{
cout << "Cat Speak" << endl;
}
};
int main()
{
Cat cat;
Animal& animal = cat;
animal.speak();
}
多态的优点:
代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护
纯虚函数和抽象类
在多态中,通常父类中虚函数的实现是毫无意义的,主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法: virtual 返回类型 函数名 (参数列表) = 0;
当类中有了纯虚函数,这个也称为抽象类
抽象类特点:
无法实例化对象
子类必须重写抽象类中的纯虚函数,否则也属于抽象类
//多态案例
//基类 抽象类
class AbstractDrinking
{
public:
virtual void Boil() = 0;//抽象类
virtual void Brew() = 0;
virtual void PourInCup() = 0;
void MakeDirnk();
};
class Coffee: public AbstractDrinking
{
virtual void Boil()
{
cout << "纯净水" << endl;
}
virtual void Brew()
{
cout << "冲泡咖啡" << endl;
}
virtual void PourInCup()
{
cout << "加入糖和牛奶" << endl;
}
};
class Tea: public AbstractDrinking
{
virtual void Boil()
{
cout << "纯净水" << endl;
}
virtual void Brew()
{
cout << "冲泡茶叶" << endl;
}
virtual void PourInCup()
{
cout << "加入枸杞" << endl;
}
};
void DoWork()
{
abs->makeDrink();
delete abs;//释放
}
void test01()
{
//制作咖啡
DoWork(new Coffee);
//制作咖啡
DoWork(new Tea);
}
int main()
{
test01();
return 0;
}
虚析构和纯虚析构
多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时无法调用子类的析构代码
解决方式:将父类中的析构函数改为虚析构或者纯虚析构
虚析构 和 纯虚析构共性:
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构区别:
如果是纯虚析构,该类属于抽象类,无法实例化对象
虚析构语法:
virtual ~ 类名(){}
纯虚析构语法:
virtual ~类名() = 0;
class Animal
{
public:
Animal()
{
cout << "Animal 构造函数调用" << endl;
}
virtual ~Animal()
{
cout << "Animal 析构函数调用" << endl;
}
virtual void Speak() = 0;
};
class Cat : public Animal
{
public:
Cat(string name)
{
m_Name = new string(name);
}
virtual void Speak()
{
cout << "小猫在说话" << endl;
}
~Cat()
{
if(m_Name != NULL)
{
delete m_Name;
m_Name = NULL;
}
}
string* m_Name;
};
void Test01()
{
Animal* animal = new Cat;
animal->Speak();
delete animal;
}