[C++学习笔记] 3. 类与对象：封装、多态、继承

已于 2022-03-30 10:24:16 修改
阅读量1.4k 收藏 1
点赞数 1
分类专栏： CPP 文章标签： c++
于 2022-03-22 15:58:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43578237/article/details/123663097
版权

3. C++类与对象：封装、多态、继承

C++面向对象的三大特性为：封装、多态、继承

对于C++来说，万事万物皆为对象，对象上有其属性和行为

注意：本文章基本没有附上代码运行结果，希望大家自己放进vscode中跑一下，把我注释掉说运行报错的语句去掉注释符，然后看看为什么报错，这样可以帮助各位读者更好地理解，因为运行结果实在太多种，大家最好还是自己跑一跑

文章目录

3.1 封装

3.1.1 封装的意义

  • 封装意义一：

​ 在设计类的时候，属性和行为写在一起，表现事物

语法： class 类名{ 访问权限： 属性 / 行为 };

  • 封装意义二：

类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

权限标识权限名称类内类外
public公共权限类内可以访问类外可以访问
protected保护权限类内可以访问类外不可以访问
private私有权限类内可以访问类外不可以访问

3.1.2 struct和class区别

唯一区别： 默认访问权限不同

  • struct 默认权限为公共
  • class 默认权限为私有

3.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

因此在封装时，若使用class

class student
{
private:  // 默认
    string name;
    int age;
    int stu_id[10];
}

若使用struct

namespace // 将结构体对外隐藏
{
    template <typename T>
    struct student
    {
        string name;
        int age;
        int stu_id[10];
    }
}

这样能保证封装内容的独立性与完整性

3.2 对象的初始化和清理

每个对象在生成时会进行初始设置，在销毁前会有清除数据的设置。

3.2.1 构造函数和析构函数

c++提供了构造函数和析构函数完成上述任务，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，如果我们不提供构造和析构，编译器会提供

编译器提供的构造函数和析构函数是空实现。

  • 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
  • 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

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

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

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

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

3.2.2 构造函数的分类和调用

两种分类方式：

​ 按参数分为： 有参构造和无参构造

​ 按类型分为： 普通构造和拷贝构造

三种调用方式：

​ 括号法

​ 显示法

​ 隐示转换法

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

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;
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
}

int main() 
{

	test01();
	//test02();
    
	return 0;
}

3.2.3 拷贝函数

默认情况下，C++便提起至少给一个类添加三个函数

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝构造函数，对属性进行值拷贝
  • 浅拷贝：简单的复制拷贝操作
  • 深拷贝：在堆区重新申请空间，进行拷贝操作

如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

注：当对象的数据资源是由指针指向堆时，默认的拷贝函数只是将指针复制，而不会开辟新的内存空间，这样会有两个指针指向同一块内存，当释放指针时，会导致该内存被释放两次，会报错。因此当类中存在指针指向的数据时，需要自己写拷贝构造函数

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {
		
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
		
	}

	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);

	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;

	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main()
{
	test01();
	return 0;
}

3.2.4 初始化列表(初始化方法)

语法：构造函数()：属性1(值1),属性2（值2）... {}

class Person {
public:

	传统方式初始化
	//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) {}

private:
	int m_A;
	int m_B;
	int m_C;
};

3.3 继承

请添加图片描述

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

3.3.1 继承的基本概念

  1. 继承的语法

    class 子类 : 继承方式 父类

  2. 继承方式一共有三种：

  • 公共继承
  • 保护继承
  • 私有继承

请添加图片描述

class Base1
{
public: 
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//公共继承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A; //可访问 public权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};

void myClass()
{
	Son1 s1;
	s1.m_A; //其他类只能访问到公共权限
}

//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2:protected Base2
{
public:
	void func()
	{
		m_A; //可访问 protected权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};
void myClass2()
{
	Son2 s;
	//s.m_A; //不可访问
}

//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3:private Base3
{
public:
	void func()
	{
		m_A; //可访问 private权限
		m_B; //可访问 private权限
		//m_C; //不可访问
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};

注意：父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

  1. 继承中的构造与析构

继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

3.3.2 菱形继承

菱形继承概念：

  • 两个派生类继承同一个基类

  • 又有某个类同时继承者两个派生类

  • 这种继承被称为菱形继承，或者钻石继承

请添加图片描述

可能的问题：最下层子类使用数据时，可能产生二义性，而且继承来自最高基类的数据只需要一份。

为了解决上述问题，我们引入虚继承

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;  //输出是最后继承的父类数据st.Tuo::m_Age 
}

输出：(st.m_Age会等于最后继承的父类数据st.Tuo::m_Age )
st.Sheep::m_Age = 100
st.Tuo::m_Age = 200
st.m_Age = 200

3.4 多态

3.4.1 多态基本概念

多态分为两类

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

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

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

多态满足条件：
1、有继承关系
2、子类重写父类中的虚函数
多态使用：
父类指针或引用指向子类对象

class Animal
{
public:
	//Speak函数就是虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	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(); //传入什么对象，那么就调用什么对象的函数
}
void test01()
{
	Cat cat; 
	DoSpeak(cat);
	Dog dog;
	DoSpeak(dog);
}

输出：
小猫在说话
小狗在说话

3.4.2 纯虚函数

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;

当类中有了纯虚函数，这个类也称为抽象类

class Base
{
public:
	//纯虚函数
	//类中只要有一个纯虚函数就称为抽象类
	//抽象类无法实例化对象
	//子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void func() = 0;
};
class Son :public Base
{
public:
	virtual void func() 
	{
		cout << "func调用" << endl;
	};
};

void test01()
{
	Base * base = NULL;
	//base = new Base; // 错误，抽象类无法实例化对象
	base = new Son;
	base->func();
	delete base;//记得销毁
}

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

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

this指针用于指向被调用的成员函数所属的对象

3.5.1 this指针作用

  • 当形参和成员变量同名时，可用this指针来区分
  • 在类的非静态函数返回对象本身，可用return *this
class Person
{
public:

	Person(int age)
	{
		//1、当形参和成员变量同名时，可用this指针来区分
		this->age = age;
	}

	Person& PersonAddPerson(Person p)
	{
		this->age += p.age;
		//返回对象本身
		return *this;
	}

	int age;
};

3.5.2 const修饰成员函数

常函数：

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

常对象：

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数
#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->m_A = 100; //不可修改

        // const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
        this->m_B = 100;
    }

    void MyFunc() const
    {
        // m_A = 10000; // 不可修改
        cout << "yes I'm here!" << endl;
    }

    void Hello()
    {
        cout << "hello" << endl;
    }

public:
    int m_A;
    mutable int m_B; //可修改 可变的
};

// const修饰对象  常对象
void test01()
{
    const Person person; //常量对象
    cout << person.m_A << endl;
    // person.m_A = 100; //常对象不能修改成员变量的值,但是可以访问
    person.m_B = 100; //但是常对象可以修改mutable修饰成员变量

    //常对象访问成员函数
    person.MyFunc(); //常对象只能调用被const修饰的常函数
    // person.Hello(); //报错，常对象不可调用普通成员函数
}

int main()
{
    test01();
    return 0;
}

3.5.3 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

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

	static int m_A; //静态成员变量
    int m_C;
    
    static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;
		//m_C = 100; //错误，不可以访问非静态成员变量
	}

private:
	static int m_B;  //类外不可访问private
};
int Person::m_A = 10;
int Person::m_B = 10;

3.6 友元

友元的作用：就是让一个函数或者类 访问另一个类中私有成员

友元修饰符：friend

  1. 全局函数做友元
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;
}
//Building b;
//goodGay(&b)
  1. 类做友元
#include <iostream>
using namespace std;
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();
    return 0;
}
  1. 成员函数做友元
class Building;
class goodGay
{
public:
    goodGay();
    void visit();  //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
    void visit2(); // visit2函数不可以访问Building中的私有内容

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();
}

3.7 关于析构函数与构造函数的补充

3.7.1 C++中析构函数的作用

  • 析构函数是一个类的成员函数，名字由波浪号接类名~student()构成。它没有返回值，也不接受参数。由于析构函数不接受参数，因此它不能被重载。对于一个给定类，只会有唯一一个析构函数。

  • 析构函数和构造函数对应，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统会自动执行析构函数。析构函数释放对象使用的资源，并销毁对象的非static数据成员。

  • 当一个类未定义自己的析构函数时，编译器会为它定义一个合成析构函数（即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，并且如果自定义了析构函数，编译器在执行时会先调用自定义的析构函数再调用合成的析构函数）。

合成析构函数按对象创建时的逆序撤销每个非static成员

  • 对于某些类，合成析构函数被用来阻止该类型的对象被销毁。否则，合成析构函数的函数体就为空。因此，许多简单的类中没有用显式的析构函数。合成析构函数无法自动释放动态内存。 如果一个类中有指针，且在使用的过程中动态的申请了内存，那么最好显式构造析构函数，在销毁类之前，释放掉申请的内存空间，避免内存泄漏。 类析构顺序：1）派生类本身的析构函数；2）对象成员析构函数；3）基类析构函数。

3.7.2 C++默认的析构函数为什么不是虚函数

C++默认的析构函数不是虚函数是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。对于不会被继承的类来说，其析构函数如果是虚函数，就会浪费内存。因此如果定义的类会被继承，一定要重新定义析构函数，并且设置为虚函数。

3.7.3 存在派生类的基类析构函数为什么必须是虚函数

  • 对与一个基类和派生类来说，在调用构造函数时先基类的构造函数，再调用派生类的构造函数；而当调用析构函数时，则要先调用派生类再调用基类的析构函数。

  • 如果定义了一个指向派生类对象的基类指针，当析构函数为普通函数时，释放该基类指针时，只会调用基类的析构函数，而不会调用派生类的析构函数，会导致内存泄漏。

  • 当基类析构函数被定义为虚函数时，在调用析构函数时，会在程序运行期间根据指向的对象类型到它的虚函数表中找到对应的虚函数==(动态绑定)==，此时找到的是派生类的析构函数，调用派生类析构函数之后再调用基类的析构函数，不会导致内存泄漏。

3.7.4 构造函数为什么不能是虚函数

如果构造函数是虚函数，那么一定有一个已经存在的类对象obj，obj中的虚指针来指向虚表的构造函数地址（通过obj的虚指针来调用）；可是构造函数又是用来创建并初始化对象的，虚指针也是存储在对象的内存空间的。总的来说就是调用虚函数需要有类的对象，但是构造函数就是用来生成对象的，所以矛盾。

3.7.5 静态函数和虚函数的区别

静态函数在编译时就已确定运行时机，虚函数在运行的时候动态绑定。虚函数因为用了虚函数表机制，调用时会增加一次内存开销。

isolatewind
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中类，对象，封装，继承（派生），多态
花狗Fdog的博客
02-17 2261
类就是同一类事物的总称，比如我（一个对象）可以讲话，那么基本上所有人都具备这个属性，就将我这一类的对象称为类，类的思想就是这样产生的。更恰当的描述：类就是世间事物的抽象称呼，而对象就是这个事物相对应的实体，人类就是一个类，写博文的我，看博文的你就是人类这个类的实例化，这也是为什么人类里面有个类，动物类，植物类，都有一个类，单说一个动物类，我们只能知道是动物，，却无法确定是那种动物，而对象就是具体实例化动物。在C++语言中，类中对象的行为是以函
[C++] 面向对象的三大特性：封装、继承和多态
Loewen丶的小窝
09-10 848
在类的定义中，前面有 virtual 关键字的成员函数称为虚函数； virtual 关键字只用在类定义里的函数声明中，写函数体时不用。 class Parent { private： int a = 20; public: parent (int a) { this—>a = a; cout<<"parent a :"<< } }; int Base::Fun() // virtual 字段不用在
C++的封装、继承、多态之封装篇
Shangzh_Wang的博客
04-22 174
C++的封装、继承、多态之封装篇前言1、封装的意义2、封装的语法3、示例一总结 前言 学习黑马程序员关于C++的笔记 1、封装的意义 c++面向对象的三大特性：封装、继承、多态 封装的意义： 将属性和行为作为一个整体，表现生活的事物 将属性和行为加以权限控制 2、封装的语法 语法： class className { 访问权限： 属性和行为； } 3、示例一 示例一 设计一个圆类，求圆的周长 class Circle { public: // } 总结 提示：这里对文章进行总结： 例如：以上
C++ 的封装、继承、多态
ice
05-31 588
面向对象的三个基本特征 面向对象的三个基本特征是：封装、继承、多态。 其中，封装可以隐藏实现细节，使得代码模块化； 继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！ ...
C++类和对象特性（继承性，封装性，多态性）
qq_46191536的博客
05-09 533
三个特性都是基于C++类与对象的 继承性 基类&派生类定义及其基本定义 当创建一个新的类时，可以指定它继承已有的类的成员。这两个类分别被称为基类，派生类。 继承，就是将基类中public和protected中的成员，全部或分别，继承到派生类中的private、protected、public中，单个或多个部分中 派生类可以从一个或多个基类继承数据和函数，定义的形式如下 class name...
C++学习笔记- 面向对象 .md
11-13
C++学习笔记，博主个人向。内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联...
C++学习笔记.pdf
02-27
这只是C++学习笔记的冰山一角，深入学习还将涉及类、对象、派生类、构造函数、析构函数、运算符重载、模板、预处理指令、容器、函数指针、函数对象以及Lambda表达式等。面向对象编程是C++的核心特性，包括封装、继承...
c++学习笔记w版.docx
02-27
通过封装、继承和多态等机制，可以创建出更加灵活和可维护的代码。特别是，`virtual`关键字用于实现多态性，例如在声明虚函数`virtual void push(char c) = 0;`时，它表示该函数可以在派生类中重定义，并且如果指针...
c++学习笔记.docx
10-25
以下是对C++学习笔记中提到的关键知识点的详细说明： 1. **板式基础**： - C++编译后的可执行文件通常为`.exe`格式，源代码文件为`.cpp`。 - `#include <iostream>`是预处理指令，用于引入标准输入输出流库，支持...
C++面向对象学习笔记
07-31
C++是一种支持面向对象编程（OOP）的高级编程语言，其面向对象特性包括类、对象、封装、继承和多态。本篇笔记主要探讨了C++程序在内存中的存储方式，即内存分区模型，包括代码区、全局区、栈区和堆区。 1. **内存...
C++封装、继承、多态
weixin_38389509的博客
05-31 743
文章目录1 内存分区模型代码区全局区栈区堆区2 引用 1 内存分区模型 内存分区的意义： 不同区域存放的数据，赋予不同的生命周期 代码区 存放函数体的二进制代码，由操作系统进行管理 存放CPU执行的机器指令 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可 代码区是只读的，使其只读的原因是防治程序意外的修改它的指令 全局区 存放全局变量和静态变量以及常量 全局变量和静态变量存放在此 全局区还包含了常量区，字符串常量和其他常量、 该区域的数据在程序结束后由操作系统释放 int g
C++之三大特性 “封装”、“继承”、“多态”
qq_49613557的博客
10-25 8796
C++之三大特性 “封装”、“继承”、“多态” 目录封装继承继承的概念及定义基类和派生类对象赋值转换继承中的作用域派生类的默认成员函数继承与友元继承与静态成员复杂的菱形继承及菱形虚拟继承继承的总结和反思多态二级目录三级目录 封装 继承 继承的概念及定义 继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触
【C++】C++三大特性——封装、继承、多态
Jacky_Feng的博客
03-22 1372
一、封装 利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节，但可以通过该对象对外的提供的接口来访问该对象。 1、封装的意义： 封装的意义在于保护或者防止代码（数据）被我们无意中破坏。 保护成员属性，不让类以外的程序直接访问和修改； 隐藏方法细节，使代码
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 95
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
C的I/O操作
weidl001的博客
06-17 721
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
C++ shared_ptr
qq_40135848的博客
06-15 1530
C++ shared_ptr
C++ 72 之 友元和类模版
最新发布
LSG_Down的博客
06-18 249
【代码】C++ 72 之 友元和类模版。
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 1172
Deque（双端队列）是C++ STL中的一种序列容器
1. 类和对象 2．接口 3．异常处理 4.类的封装、继承与多态的实现
05-30
4. 类的封装、继承与多态的实现：类的封装是指将类的属性和方法封装起来，只暴露必要的接口给外部使用，从而提高了代码的安全性和可维护性。类的继承是指子类可以继承父类的属性和方法，从而避免了代码的重复和冗余...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值