C++面向对象基础知识

已于 2024-08-20 11:05:35 修改
阅读量392 收藏 7
点赞数 3
文章标签： c++
于 2024-08-13 15:56:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jrrz0828/article/details/141164622
版权

目录

1.内存分区

2.引用

2.1引用的基本使用

2.2引用的本质

2.3常量引用

3.函数重载

3.1函数重载的作用

3.2函数重载满足条件

4.类与对象

4.1封装

4.1.1封装的意义

4.1.2构造函数与析构函数

4.1.3拷贝构造函数

4.1.4深拷贝与浅拷贝

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

4.1.6友元

4.1.7运算符重载

4.2继承

 4.2.1继承的优点

4.2.2继承方式

4.2.3继承中的构造和析构顺序

4.2.4继承同名成员处理方式

4.2.5多继承

4.2.6菱形继承

4.3多态

4.3.1多态的满足条件

4.3.2纯虚函数和抽象类

4.3.3虚析构和纯虚析构

1.内存分区

C++程序在执行时，将数据存放在不同的区域，赋予其不同的生命周期，给编程以更多的灵活性。

代码区存放函数体的二进制代码，由操作系统进行管理
全局区存放全局变量、静态变量及常量
栈区由编译器自动分配释放，存放函数的参数值，局部变量等
堆区

由程序员分配和释放，若程序员未释放，则在程序结束后由操作系统回收

2.引用

2.1引用的基本使用

给变量起别名

int a = 10;
int &b = a;

2.2引用的本质

引用的本质是一个指针常量（即该指针是一个常量，指针所指向的值可以更改）

2.3常量引用

在函数形参列表中，可以加const修饰形参，防止形参改变实参，例如：

//引用使用的场景，通常用来修饰形参
void showValue(const int& v) {
	cout << v << endl;
}

3.函数重载

3.1函数重载的作用

函数的名称可以相同，以提高复用性

3.2函数重载满足条件

  • 在同一个作用域下
  • 函数名称相同
  • 函数参数类型不同或个数不同或顺序不同
//函数重载需要函数都在同一个作用域下
void func()
{
	cout << "func 的调用！" << endl;
}
void func(int a)
{
	cout << "func (int a) 的调用！" << endl;
}
void func(double a)
{
	cout << "func (double a)的调用！" << endl;
}
void func(int a ,double b)
{
	cout << "func (int a ,double b) 的调用！" << endl;
}
void func(double a ,int b)
{
	cout << "func (double a ,int b)的调用！" << endl;
}

//函数返回值不可以作为函数重载条件
//int func(double a, int b)
//{
//	cout << "func (double a ,int b)的调用！" << endl;
//}


int main() {

	func();
	func(10);
	func(3.14);
	func(10,3.14);
	func(3.14 , 10);
	
	system("pause");

	return 0;
}

4.类与对象

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

C++认为万物皆对象，对象有其属性和行为

 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…

​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调…

​ 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

4.1封装

4.1.1封装的意义

  • 将属性和行为作为一个整体，表现生活中的事物
  • 将属性和行为放在不同的权限下加以控制
三种权限
公共权限  public     类内可以访问  类外可以访问
保护权限  protected  类内可以访问  类外不可以访问
私有权限  private    类内可以访问  类外不可以访问

struct和class的区别在于默认访问权限不同，class中通过将成员属性设置为私有，可自己控制读写权限，保证数据的隐私与安全

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

4.1.2构造函数与析构函数

       对象的初始化和清理是两个非常重要的安全问题。一个对象或变量没有初始状态，对其使用的后果是未知的。同样，在使用完一个对象或变量后，没有及时清理，会造成一定的安全问题。

       C++中使用构造函数和析构函数完成对象的初始化和清理，这两个函数会被编译器自动调用。

       对象的初始化和清理工作是编译器强制要求的，因此如果我们不提供构造和析构，编译器会提供构造函数和析构函数的空实现。

class Person
{
public:
	//构造函数
    //构造函数语法：类名(){}
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
    //析构函数语法： ~类名(){}
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

4.1.3拷贝构造函数

C++中拷贝构造函数调用时机通常有三种情况

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

构造函数调用规则

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

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

  • 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

  • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

4.1.4深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

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

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

	system("pause");

	return 0;
}

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

在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上。

class Person {
public:
	Person() {
		mA = 0;
	}
	//非静态成员变量占对象空间
	int mA;
	//静态成员变量不占对象空间
	static int mB; 
	//函数也不占对象空间，所有函数共享一个函数实例
	void func() {
		cout << "mA:" << this->mA << endl;
	}
	//静态成员函数也不占对象空间
	static void sfunc() {
	}
};

int main() {

	cout << sizeof(Person) << endl;

	system("pause");

	return 0;
}

 this指针概念

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

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

void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
    //链式
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.1.6友元

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

友元的三种实现

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

下面分别举例说明：

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


void test01()
{
	Building b;
	goodGay(&b);
}

int main(){

	test01();

	system("pause");
	return 0;
}

2. 类做友元

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

3.成员函数做友元


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

4.1.7运算符重载

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

       以加号运算符重载为例，实现两个自定义数据类型相加的运算：

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


public:
	int m_A;
	int m_B;
};

//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
//	Person temp(0, 0);
//	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(10, 10);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; //相当于 operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

int main() {

	test();

	system("pause");

	return 0;
}

4.2继承

 4.2.1继承的优点

 继承是面向对象三大特性之一，通过继承可以减少重复的代码。

4.2.2继承方式

 继承的语法：class 子类 : 继承方式 父类

class A : public B;

A 类称为子类 或 派生类（包含两部分：一类是从基类继承过来的；一类是自己增加的）

B 类称为父类 或 基类

继承方式一共有三种：

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

4.2.3继承中的构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数。

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

4.2.4继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
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;
}

4.2.5多继承

C++允许一个类继承多个类

语法： class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

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

4.2.6菱形继承

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

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问题
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;
}

4.3多态

多态是C++面向对象三大特性之一

多态分为两类

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

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

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

4.3.1多态的满足条件

多态满足条件

  • 有继承关系
  • 子类重写父类中的虚函数

多态使用条件

  • 父类指针或引用指向子类对象

重写：函数返回值类型 函数名 参数列表 完全一致称为重写

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();
}
//
//多态满足条件： 
//1、有继承关系
//2、子类重写父类中的虚函数
//多态使用：
//父类指针或引用指向子类对象

void test01()
{
	Cat cat;
	DoSpeak(cat);


	Dog dog;
	DoSpeak(dog);
}


int main() {

	test01();

	system("pause");

	return 0;
}

4.3.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;//记得销毁
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.3.3虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

虚析构和纯虚析构共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构区别：

  • 如果是纯虚析构，该类属于抽象类，无法实例化对象
class Animal {
public:

	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	virtual void Speak() = 0;

	//析构函数加上virtual关键字，变成虚析构函数
	//virtual ~Animal()
	//{
	//	cout << "Animal虚析构函数调用！" << endl;
	//}


	virtual ~Animal() = 0;
};

Animal::~Animal()
{
	cout << "Animal 纯虚析构函数调用！" << endl;
}

//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用！" << endl;
		m_Name = new string(name);
	}
	virtual void Speak()
	{
		cout << *m_Name <<  "小猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat析构函数调用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}

public:
	string *m_Name;
};

void test01()
{
	Animal *animal = new Cat("Tom");
	animal->Speak();

	//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
	//怎么解决？给基类增加一个虚析构函数
	//虚析构函数就是用来解决通过父类指针释放子类对象
	delete animal;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：

​ 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

​ 2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

​ 3. 拥有纯虚析构函数的类也属于抽象类

jrrz0828
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++入门 面向对象的基础
AltarS的博客
03-27 260
C++是一门面向对象的语言，在C语言的基础上有了进一步的扩充与完善。1、面向对象的特征：封装：封装是一个用来将对象的状态和行为捆绑到一个单一逻辑单元机制的正式术语。不是面向对象语言所特有，在面向过程的C语言中用结构封装了数据，函数封装了逻辑。但是面向对象封装了数据和逻辑，一定意义上面向对象的封装更加完美。继承：继承是定义新类的一种机制，使用这种机制创建新类时只需要声明新类和已创建类之间的差别，对于...
C++笔记：面向对象编程基础
liufei_learning--脚踏实地，戒骄戒躁！
03-18 7081
面向对象编程基础 面向对象编程基于三个基本概念： 数据抽象－继承－动态绑定
c++面向对象编程
最新发布
qq_45592093的博客
07-09 1639
面向对象编程的几个重要概念：类&对象，封装、继承、多态、抽象
C++面向对象（基础）
choudan8888的博客
11-12 131
1.构造函数 用例实例化对象的时候调用的成员方法： 构造函数没有返回值，函数名与类名同名，参数没有规定(根据需要) 实例化对象的时候必须调用构造函数 一旦自己内有实现构造函数，编译器就会为我们自动默认生成一个构造函数 默认的构造函数就是没有参数的构造函数 示例如下： class Person { private: char *_name; bool _sex; int _age...
C++：面向对象基础
sqk_nuist的博客
04-10 332
1、结构体成员默认的属性是公共的，而类成员默认是私有的。C++的结构体也可以设置 public,private。但C语言中不行。2、内联函数和外联函数在类体内实现的成员函数称为内联函数，在调用处用内联函数体的代码来替换，提高运行速度。在类体外实现的成员函数称为外联函数。外联函数转换成内联函数时只要在外部函数定义前加上 inline 就可以，不需要在类内部声明处加。3、不宜使用内联函数的两种情况：1...
c++面向对象的基础
weixin_47981893的博客
06-10 129
但是如果对象的属性有指针类型时，浅拷贝也只会简单的地址值的复制，这时两个对象的指针保存同一块地址，指向了同一块内存。如果没有显示给出构造函数，编译器会给出默认的构造函数（参数为空，并且函数体为空）并没有实际操作，如果写出任意构造函数，编译器默认的构造函数就不存在。等号赋值时，等号左侧是对象类型，右侧恰好是对象构造函数所需要的类型，这时就会把右侧值传入到构造函数中，相当于隐式调用构造函数。如果类中都是基本数据类型和string 类型，这时可以不显示写出析构函数，对象的数据会随着对象的销毁而销毁。
《C++面向对象程序设计》第2版编程题答案
02-26
《C++面向对象程序设计》是C++编程领域的一本经典教材，由清华大学出版社出版，龚晓庆、付丽娜等多位专家共同编著。这本书深入浅出地讲解了C++语言的核心概念，特别是面向对象编程（OOP）的思想和技术。第二版在第一...
C++面向对象程序设计_C++_C++面向对象_ppt_
10-04
这个PPT对于初学者来说是一份宝贵的资源，它不仅涵盖了C++面向对象的基础知识，还可能深入到一些高级主题，帮助学习者全面理解并掌握面向对象编程在C++中的实践应用。通过学习和理解这些内容，开发者将能够利用C++的...
C++面向对象复习题.doc
11-16
本文档总结了C++面向对象编程的重要知识点，涵盖了面向对象编程的基本概念、类和对象的定义、成员函数的实现、运算符重载、继承和多态等方面的知识。 一、类和对象的定义 在C++中，类是面向对象编程的基础概念。类...
C++面向对象程序设计教程——课件PPT
10-19
C++是一种强大的编程语言，以其...这个PPT课件系列涵盖了C++面向对象编程的主要知识点，对于初学者和进阶者都是极好的学习资源。通过系统学习和实践，开发者可以掌握C++的精髓，从而编写出高效、可维护的面向对象程序。
C++面向对象程序设计教程课后习题答案ppt课件.ppt
11-16
本资源为C++面向对象程序设计教程课后习题答案ppt课件，涵盖了C++基础知识、函数重载、函数重写、指针、数组等多个方面的知识点。 1. C++基础知识： C++是一种面向对象的程序设计语言，它支持封装、继承和多态三个...
C++ 面向对象基础
KafenWong的博客
04-30 829
C++
C++面向对象基础
kzzyf的博客
06-24 349
目录C++类成员函数：C++类访问修饰符：类的构造函数和析构函数：拷贝构造函数：C++友元函数：C++内联函数：C++静态成员变量和静态成员函数：C++继承：C++重载函数和重载运算符：C++多态：C++接口（抽象类）： 类成员函数就是类的一员，它可以操作类的任意对象，可以访问对象中的所有成员。成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。 数据封装是面向对象编程的一个重要特点，
C++面向对象基础（一）
Mao1253的博客
03-17 315
   本人在学习C++的面向对象学习中有自己的一些拙见，一些遇到的简单问题和对问题的看法，可能不是很专业，但也想记录下来，算是学习的心得。大家浏览之余若发现不足之处可以留言哟！共同学习，共同进步！霍霍！       1.面向对象是什么？            面向对象是一种程序设计思想，如同C语言面向过程来设计程序一样，当人们写大中型程序的时候，面向过程的方法就不再实用，对于如今的高级语言，面向对...
c++面向对象基础（一）
MyFamily_IT的博客
03-17 376
一，面向对象与面向过程的比较1，面向过程程序设计核心：算法和数据，“程序=算法+数据结构”。”先功能后数据”的思想。当问题规模不大时，因面向过程的设计方法逻辑清楚，实现简单，是最方便的。局限性：问题规模过大时，同一时刻的数据共用导致最终软件产品的不安全，代码重用率低等问题而低效。2，面向对象的程序设计方法把状态（数据）和行为（功能）捆绑在一起，形成了对象。面向对象有三个特点：封装，继承，多态。封装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值