[C++核心编程]（五）：类和对象——对象特性

已于 2024-03-16 22:56:51 修改
阅读量1.6k 收藏 21
点赞数 48
分类专栏： C++打怪升级 文章标签： c++ 开发语言
于 2024-02-29 16:46:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43430048/article/details/136361311
版权
本文详细介绍了C++中的构造函数、析构函数、拷贝构造函数、初始化列表、静态成员、this指针、空指针以及const修饰的成员函数。讲解了它们的作用、调用规则和注意事项，帮助读者理解面向对象编程的核心概念。
摘要由CSDN通过智能技术生成

目录

对象的初始化和清理

构造函数和析构函数

构造函数

  构造函数的分类和调用

  拷贝构造函数的调用时机

  构造函数的调用规则

  深拷贝和浅拷贝*

  初始化列表

  类对象作为类成员

  静态成员（static）

析构函数

对象模型和this指针

this指针

空指针访问成员函数

const修饰成员函数

对象的初始化和清理

     c++中的面向对象来源于生活，每个对象都会有初始设置以及对象销毁前的清理数据的设置

构造函数和析构函数

  • 编译器自动调用，完成对象初始化和清理工作
  • 如果程序员不自行实现，编译器提供的都是空实现

构造函数

     作用：创建对象时为对象的成员属性赋值，编译器自动调用，无须手动调用

     语法： 类名 () {}

  1. 没有返回值，也不用写void
  2. 函数名称与类名相同
  3. 可有参数，可重载
  4. 自动调用，无须手动调用且只调用一次
    构造函数的分类和调用

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

        调用方法：括号法、显示法、隐式转换法

        匿名对象：执行结束后，立即释放该对象。

        注意：

        1.创建对象时调用默认构造函数的时候不要加(),编译器认为是一个函数声明;

        2.不要使用拷贝构造函数初始化匿名对象，编译器认为是一个对象声明；

    拷贝构造函数的调用时机

        1.使用创建完毕的对象初始化一个新对象

        2.值传递的方式给函数参数传值

        3.以值方式返回局部对象

#include <iostream>
using namespace std;

class Cube
{
public:
	int m_L;

	Cube()
	{
		cout << "Cube 无参默认构造函数 调用" << endl;
	}
	Cube(int a)
	{
		m_L = a;
		cout << "Cube 有参构造函数 调用" << endl;
	}
	Cube(const Cube &p)
	{
		m_L = p.m_L;
		cout << "Cube 拷贝构造函数 调用" << endl;
	}

	~Cube()
	{
		cout << "Cube 析构函数 调用" << endl;
	}
};

//使用创建完毕的对象初始化一个新对象
void test01()
{
	Cube p1(20);
	Cube p2(p1); 
	cout << "p2 m_L value:" << p2.m_L << endl;

}

//值传递的方式给函数参数传值
void dowork1(Cube p)
{
	cout << "p m_L value:" << p.m_L << endl;
}

void test02()
{
	Cube s1(30);
	dowork1(s1);
}

//以值方式返回局部对象
Cube dowork2(void)
{
	Cube m1(40);
	cout << (int*)&m1 << endl;
	return m1;
}

void test03()
{
	Cube m = dowork2();
	cout << (int*)&m << endl;
	cout << "m m_L value:" << m.m_L << endl;
}

int main(void)
{
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}
    构造函数的调用规则

        默认情况，编译器至少给一个类添加三个函数：

        1.默认构造函数（无参，函数体为空）

        2.默认析构函数（无参，函数体为空）

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

        调用规则：

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

        2.如果用户定义拷贝构造函数，c++不再提供其它构造函数

   深拷贝和浅拷贝*

        浅拷贝：简单的赋值拷贝操作，将原对象或原数组的引用赋给新对象

        深拷贝：在堆区重新申请空间存储数据，创建一个新的对象。

        注意：数据成员中如果有指针，必须用深拷贝

#include <iostream>

using namespace std;

class Cube
{
public:
	int m_L;
	int* p_H;

	Cube()
	{
		cout << "Cube 无参默认构造函数 调用" << endl;
	}
	Cube(int a, int Hight)
	{
		m_L = a;
		p_H = new int(Hight);
		cout << "Cube 有参构造函数 调用" << endl;
	}

	//自行实现拷贝构造函数，解决浅拷贝的问题
	Cube(const Cube& p)
	{
		m_L = p.m_L;
		p_H = new int(*p.p_H); //深拷贝
	}

	~Cube()
	{
		if (p_H != NULL)
		{
			delete p_H;
			p_H = NULL;
		}
		cout << "Cube 析构函数 调用" << endl;
	}
};

//浅拷贝,问题：堆区的内存重复释放，使用深拷贝解决
void test01()
{
	Cube p1(20, 40);
	cout << "p1 m_L and p_H value:" << p1.m_L << "," << *p1.p_H << endl;
	Cube p2(p1); 
	cout << "p2 m_L and p_H value:" << p2.m_L << "," << *p2.p_H << endl;
}


int main(void)
{
	test01();
	system("pause");
	return 0;
}
  初始化列表

        作用：用于初始化属性

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

#include <iostream>

using namespace std;

class Cube
{
public:
	int m_L;
	int m_H;
	//初始化列表初始化属性
	Cube(int a, int b) :m_L(a), m_H(b)
	{

	}
};

int main(void)
{
	Cube p1(10, 20);
	cout << "p1 m_L and p_H value:" << p1.m_L << "," << p1.m_H << endl;
	system("pause");
	return 0;
}
  类对象作为类成员

        c++类中的成员可以是另一个类的对象；

        注意：先构造类对象，再构造自身；析构与构造相反。

#include <iostream>
#include <string>

using namespace std;

class Phone
{
public:
	string m_phname;

	Phone(string pname)
	{
		m_phname = pname;
		cout << "Phone 构造函数调用" << endl;
	}
	~Phone()
	{
		cout << "Phone 析构函数调用" << endl;
	}
};

class Person
{
public:
	string m_name;
	Phone m_phone;
	//初始化列表初始化属性
	Person(string name, string phname) :m_name(name), m_phone(phname)
	{
		cout << "Person 构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person 析构函数调用" << endl;
	}
};

void test()
{
	Person p1("zhangsan", "HUAWEI");
	cout << p1.m_name << "拿着" << p1.m_phone.m_phname << "手机！" << endl;
}

int main(void)
{
	test();
	system("pause");
	return 0;
}
  静态成员（static）

  • 静态成员变量

        1.所有对象共享同一份数据

        2.在编译阶段分配内存

        3.类内声明，类外初始化

  • 静态成员函数

        1.所有对象共享同一个函数

        2.静态成员函数只能访问静态成员变量

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_B;
	static int phone_number;

	static void func()
	{
		phone_number = 900;
		cout << "static void func()调用" << endl;
	}
private:
	static int number;  //也可以访问
	static void func2()
	{
		phone_number = 900;
		cout << "static void func2()调用" << endl;
	}
};

int Person::phone_number = 123;
int Person::number = 123;

void test()
{
	Person p1;
	p1.phone_number = 100;
	p1.func();
	cout << "p1.phone_number:" << p1.phone_number << endl;

	Person p2;
	p2.phone_number = 200;
	cout << "p1.phone_number:" << p1.phone_number << endl;
	cout << "p1.phone_number:" << p2.phone_number << endl;

	Person::func();
	//Person::func2(); //私有的无法访问
	cout << "phone_number:" << Person::phone_number << endl; //通过类名访问
	//cout << "phone_number:" << Person::number << endl; //私有的无法访问
}

int main(void)
{
	test();
	system("pause");
	return 0;
}

析构函数

      作用：对象销毁前系统自动调用，执行一些清理工作

      语法： ~类名() {}

  1. 没有返回值，也不用写void
  2. 函数名称与类名相同，在名称前加上符号~
  3. 无参数，无法重载
  4. 自动调用，无须手动调用且只调用一次
#include <iostream>

using namespace std;

class Cube
{
public:
	int m_L;

	Cube()
	{
		cout << "Cube 无参默认构造函数 调用" << endl;
	}
	Cube(int a)
	{
		m_L = a;
		cout << "Cube 有参构造函数 调用" << endl;
	}
	//拷贝构造函数
	Cube(const Cube &p)
	{
		m_L = p.m_L;
		cout << "Cube 拷贝构造函数 调用" << endl;
	}

	~Cube()
	{
		cout << "Cube 析构函数 调用" << endl;
	}
};

void test01()
{
	//括号法
	Cube p1;      //无参
	Cube p2(20);  //有参
	Cube p3(p2);  //拷贝

	cout << "p2 m_L:" << p2.m_L << endl;
	cout << "p3 m_L:" << p3.m_L << endl;

	//显示法
	Cube s1;
	Cube s2 = Cube(10);
	Cube s3 = Cube(s2);

	//Cube(10);  //匿名对象，特点：当前行执行结束后，立即释放该对象。

	cout << "s2 m_L:" << s2.m_L << endl;
	cout << "s3 m_L:" << s3.m_L << endl;

	//Cube(s3); 相当于 Cube s3;  不要使用拷贝构造函数初始化匿名对象

	//隐式转换法
	Cube s4 = 15;
	Cube s5 = s4;
	cout << "s4 m_L:" << s4.m_L << endl;
	cout << "s5 m_L:" << s5.m_L << endl;
}

int main(void)
{
	test01();
	system("pause");
	return 0;
}

对象模型和this指针

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

#include <iostream>
#include <string>

using namespace std;

class Person
{
	int m_A; //非静态成员变量，属于类的对象上

	static int m_B; //静态成员变量，不属于类的对象上

	void func() //非静态成员函数，不属于类的对象上
	{

	}
	static void func1() //静态成员函数，不属于类的对象上
	{

	}
};


void test()
{
	Person p;
	//空对象占用内存空间为：1，为了区分多个空对象占内存的位置，每个空对象的内存都是唯一的；
	cout << "size of p = " << sizeof(p) << endl;
}

void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}

int main(void)
{
	test();
	test02();
	system("pause");
	return 0;
}

this指针

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

        1.隐含每一个非静态成员函数内的一种指针

        2.不需要定义，直接使用

        用途：

        1.当形参和成员变量同名时，可以使用this指针区分

        2.在类的非静态成员函数中返回对象本身，可以使用 return *this

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int age;

	Person(int age)
	{
		//指向 被调用的成员函数 所属的对象
		this->age = age;
	}

	Person& PersonAddAge(Person p) //如果用值Person返回 ，会创建一个新的对象
	{
		this->age += p.age;
		return *this;
	}
};

//1.解决名称冲突
void test()
{
	Person p1(10);
	cout << "p1 age = " << p1.age << endl;

}

void test1()
{
	Person p1(10);
	Person p2(10);

	//链式 编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);

	cout << "p2 age = " << p2.age << endl;

}

//2.返回对象本身用*this

int main(void)
{
	test();
	test1();
	system("pause");
	return 0;
}

空指针访问成员函数

        c++空指针可以访问成员函数，如果用到this指针要判断保证代码的健壮性

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_Age;

	void showClassName()
	{
		cout << "this is Person Class" << endl;
	}

	void showPersonAge()
	{
		if (this == NULL)
			return;
		cout << "age=" << m_Age << endl;
	}
};

void test()
{
	Person* p = NULL;

	p->showClassName();

	p->showPersonAge();

}

int main(void)
{
	test();
	system("pause");
	return 0;
}

const修饰成员函数

常函数：

        1.成员函数后加const后成为常函数

        2.常函数内不可以修改成员属性       

        3.成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

        1.声明对象前加const称为常对象

        2.常对象只能调用常函数

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_Age;
	mutable int m_B; //mutable 常函数中也可以修改

	Person(int a, int b)
	{
		m_Age = a;
		m_B = b;
	}

	//this指针的本质： 指针常量  指针的指向不可以修改 Person * const this;
	void showClassName(int b) const //修饰的this指针，相当于const Person * const this，让指针指向的值也不可以修改;
	{
		//this->m_Age = 100;  错误 无法修改
		this->m_B = b;
	}

	void func()
	{
		cout << "void func()" << endl;
	}
};

void test()
{
	Person p(1,2);
	p.showClassName(50);
	cout << "m_Age:" << p.m_Age << "\tm_B:" << p.m_B << endl;

	const Person m(4,5); 
	//m.m_Age = 10; 无法调用
	m.m_B = 30;
	m.showClassName(100);//常函数只能调用常函数
	//m.func();
	cout << "m_Age:" << m.m_Age << "\tm_B:" << m.m_B << endl;
}

int main(void)
{
	test();
	system("pause");
	return 0;
}

推荐文章：[C++核心编程]（四）：类和对象——封装

盖世汤猿
关注
  • 48
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Modern C++ 学习笔记——C++面向对象编程
小小笑笑川的博客
07-02 740
结合三种设计模式，让你更加理解C++面向对象的特性，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
C++基础入门：面相对象编程C++中的封装、继承和多态.docx
08-06
总结来说，C++的面向对象特性——封装、继承和多态，为程序设计提供了更灵活、更具表达力的方式。封装确保数据安全，继承促进代码重用，多态则允许灵活的接口处理。在实际编程中，熟练掌握这三个概念及其应用，能...
C++核心编程（四）—— 类和对象(1) ：封装
大彤小忆的博客
03-30 3860
1. 类和对象概述2. 封装2.1 封装的意义2.2 struct和class区别2.3 成员属性设置为私有3. 对象的初始化和清理4. C++对象模型和this指针5. 友元6. 运算符重载7. 继承8. 多态 1. 类和对象概述   C++在C语言的基础上增加了面向对象编程，C++支持面向对象的程序设计。类是C++的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。   类的基本思想是数据抽象(data abstractio.
《黑马》——C++核心编程
热门推荐
漏网小鱼的博客
09-05 21万+
前言： ** 配套视频： https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=16795623907667609637 只是为方便学习，不做其他用途，在此发布C++基础入门部分配套讲义，原作者为黑马程序 C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局
[C++核心编程]（九）：类和对象——多态**
weixin_43430048的博客
03-14 1231
[C++核心编程]（九）：类和对象——多态**
C++: RAII是什么——使用对象来管理资源
wsqiangz的博客
10-29 1566
在本文中，我们介绍了C++中的RAII技术，它是一种管理资源的方法，可以帮助我们避免内存泄漏和资源泄漏等问题。在函数中由栈管理的临时对象，在函数结束时会自动析构，从而自动释放资源，因此，我们可以。本文较为详细介绍了RAII的原理、使用方法和优点，并且通过实例讲解了RAII在C++ STL中的应用，如智能指针和互斥锁等，在最后进行了编程实践。
C++核心编程（四）—— 类和对象(6) ：继承
大彤小忆的博客
04-05 3364
6. 继承6.1 继承的基本语法6.2 继承方式6.3 继承中的对象模型6.4 继承中构造和析构顺序6.5 继承同名成员处理方式6.6 继承同名静态成员处理方式6.7 多继承语法6.8 菱形继承 6. 继承   面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。   当创建一个类时，我们不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基.
C++核心编程（四）—— 类和对象(7) ：多态
大彤小忆的博客
04-05 3359
7. 多态7.1 多态的基本概念7.2 多态案例1 —— 计算器类7.3 纯虚函数和抽象类7.4 多态案例2 —— 制作饮品7.5 虚析构和纯虚析构7.6 多态案例3 —— 电脑组装 7. 多态 7.1 多态的基本概念   多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。   多态是C++面向对象三大特性之一。多态分为两类： 静态多态：函数重载和运算符重载属于静态多态，复用函数名； .
【JAVA学习】2、面向对象编程的核心——对象和类
陈艺荣
09-18 1543
【JAVA学习】面向对象编程的核心——对象和类前言面向过程VS面向对象基础概念优缺点比较面向对象三大基础特性封装继承多态面向对象编程的五大基本原则单一职责原则SRP(Single Responsibility Principle)开放封闭原则OCP(Open－Close Principle)里式替换原则LSP(the Liskov Substitution Principle LS)依赖倒置原则DIP(the Dependency Inversion Principle DIP)接口分离原则ISP(the
【C++入门系列】——类和对象
lovewold_的博客
10-21 2917
本章主要讲述C++的类和对象特性，同时对auto关键字进行一个简要讲解，并简要完善前面章节未完成部分。在本章节，我们主要学习到auto关键字的合理用途，接触类和对象的面纱。能理解什么是面向过程，什么是面向对象，并且对类进行一个初步了解，了解在规则上的特点和用处。C语言结构体中只能定义变量，在C++中，不仅可以定义变量，还可以定义函数。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类被称为类的成员。
c++ 谭浩强例题 类和对象源码 在一个工程中 vc++ 6.0 c++ 讲稿
05-09
在C++编程语言中，类和对象是核心概念，它们是面向对象编程（Object-Oriented Programming, OOP）的基础。谭浩强教授是中国计算机科学领域知名的教育家，他的教材和例题对于初学者理解C++有着极大的帮助。在这个工程...
C++新特性详细解析语言核心特性解析
12-15
C++新特性详细解析语言核心特性解析 C++语言自2011年开始进入快速...C++语言正在不断更新和完善，它的新特性和核心特性使得它变得更加强大和灵活。作为程序员的我们，需要不断学习和更新，以适应C++语言的发展和变化。
每天学点C++（C++实例教程：教程+源码）类和对象.zip
06-21
这个"每天学点C++（C++实例教程：教程+源码）类和对象.zip"压缩包显然专注于C++的核心概念——类和对象，这是理解C++面向对象编程的基础。 在C++中，类是数据和操作数据的方法的集合，可以看作是创建对象的蓝图。类...
C++整理笔记word版 ——02 C++核心编程
12-06
C++是一种强大的面向对象编程语言，其核心编程技术包括内存管理、面向对象特性以及函数的高级用法。本文将深入探讨这些关键知识点。 首先，我们要理解C++的内存分区模型。程序在运行时，内存被划分为四个主要区域：...
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 330
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 443
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 220
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ STL专题 list的讲解
Mike的博客
08-07 735
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值