C++面向对象之类和对象那些你不知道的细节原理详解

目录
  • 一、类和对象、this指针
  • 二、掌握构造函数和析构函数
  • 三、掌握对象的深拷贝和浅拷贝
  • 四、类和对象应用实践
  • 五、掌握构造函数的初始化列表
  • 六、掌握类的各种成员方法及其区别
  • 总结

一、类和对象、this指针

OOP语言的四大特征是什么?

  • 抽象
  • 封装、隐藏
  • 继承
  • 多态

类体内实现的方法会自动处理为inline函数。

类对象的内存大小之和成员变量有关

类在内存上需要对齐,是为了减轻cup在内存上的io次数

查看类对象的大小的指令:cl className.cpp /d1reportSingleClassLayout类名

一个类可以定义无数个对象,每个对象都有自己的成员变量,但是他们共享一套成员方法。

有一个问题:Q1:类中的成员方法是怎么知道要处理哪个对象的信息的?

A1:在调用成员方法的时候会在参数列表里隐式的给定对象内存的地址。如下所示:

类的成员方法一经编译,所有方法参数都会加一个this指针,接收调用该方法的对象的地址,即下图中的CGoods *this

二、掌握构造函数和析构函数

定义一个SeqStack类:

class SeqStack
{

public:
	SeqStack(int size = 10) :_top(-1), _size(size) {
		_pstack = new int[size];
	}
	~SeqStack() {
		cout << this << "~SeqStack()" << endl;
		delete[] _pstack;
		_pstack = nullptr;
	}

	void push(int val) {
		if (full()) {
			resize();
		}
		_pstack[++_top] = val;
	}

	void pop() {
		if (empty()) {
			return;
		}
		--_top;
	}

	int top() {
		return _pstack[_top];
	}
	bool empty() { return _top == -1; }
	bool full() { return _top == _size-1; }

private:
	int* _pstack;

	int _top;

	int _size;

	void resize() {
		int* ptmp = new int[_size * 2];
		for (int i = 0; i < _size; i++) {
			ptmp[i] = _pstack[i];
		}
		delete[] _pstack;
		_pstack = ptmp;
		_size *= 2;
	}
};
/**
	运行过程
*/
int main() {
	SeqStack sq1;

	for (int i = 0; i < 15; i++) {
		sq1.push(rand() % 100);
	}

	while (!sq1.empty()) {
		cout << sq1.top() << " ";
		sq1.pop();
	}

	return 0;
}

三、掌握对象的深拷贝和浅拷贝

.data段的对象是程序启动的时候构造的,程序结束的时候析构的

heap堆上对象是new的时候构造的,delete的时候析构的

stack栈上的对象是在调用函数的时候构造的,执行完函数时析构的

如果对象占用外部资源,浅拷贝就会出现问题:会导致一个对象指向的内存释放,从而造成另一个对象中的指针成为野指针。所以就要对这样的对象进行深拷贝,在新的对象中重新开辟一块空间,使两者互不干涉。

注意:在面向对象中,要避免使用memcpy进行拷贝,因为对象的内存占用不确定,会因为对象中保存指针而造成浅拷贝。需要拷贝的时候只能用for循环逐一拷贝。

深拷贝:

	SeqStack& operator=(const SeqStack& src) {
		cout << "operator=" << endl;
		//防止自赋值
		if (this == &src) {
			return *this;
		}
		delete[] _pstack;//需要释放掉自身占用的外部资源
		_pstack = new int[src._size];
		for (int i = 0; i <= src._top; i++) {
			_pstack[i] = src._pstack[i];
		}
		_top = src._top;
		_size = src._size;
		return *this;
	}

	SeqStack(const SeqStack& src) {
		cout << this << "SeqStack(const SeqStack& src)" << endl;
		_pstack = new int[src._size];
		for (int i = 0; i <= src._top; i++) {
			_pstack[i] = src._pstack[i];
		}
		_top = src._top;
		_size = src._size;
	}

四、类和对象应用实践

类Queue:

#pragma once
class CirQueue
{
public:
	CirQueue(int size = 10) {
		_pQue = new int[size];
		_front = _rear = 0;
		_size = size;
	}

	CirQueue(const CirQueue& src) {
		_size = src._size;
		_front = src._front;
		_rear = src._rear;
		_pQue = new int[_size];
		for (int i = _front; i != _rear; i = (i + 1) % _size) {
			_pQue[i] = src._pQue[i];
		}
	}

	~CirQueue() {
		delete[] _pQue;
		_pQue = nullptr;
	}

	CirQueue& operator=(const CirQueue& src) {
		if (this == &src) {
			return *this;
		}
		delete[] _pQue;//需要释放掉自身占用的外部资源
		_size = src._size;
		_front = src._front;
		_rear = src._rear;
		_pQue = new int[_size];
		for (int i = _front; i != _rear; i = (i + 1) % _size) {
			_pQue[i++] = src._pQue[i];
		}
		return *this;
	}

	void push(int val) {
		if (full()) {
			resize();
		}
		_pQue[_rear] = val;
		_rear = (_rear + 1) % _size;
	}
	void pop() {
		if (empty()) {
			return;
		}
		_front = (_front + 1) % _size;
	}

	int front() {
		return _pQue[_front];
	}

	bool full() {
		return (_rear + 1) % _size == _front;
	}

	bool empty () {
		return _front == _rear;
	}

private:
	int* _pQue;

	int _front;

	int _rear;

	int _size;

	void resize() {
		int* ptmp = new int[_size * 2];
		int index = 0;
		for (int i = _front; i != _rear; i=(i+1)%_size) {
			ptmp[index++] = _pQue[i];
		}
		delete[] _pQue;
		_pQue = ptmp;
		_front = 0;
		_rear = index;
		_size *= 2;
	}
};

类String:

#pragma once
#include <algorithm>
class String
{
public:

	String(const char* str = nullptr) {
		if (str != nullptr) {
			_pChar = new char[strlen(str) + 1];
			strcpy(_pChar, str);
		}
		else {
			_pChar = new char[1];
			*_pChar = '\0';
		}
	}

	String(const String& str) {
		_pChar = new char[strlen(str._pChar)+1];
		strcpy(_pChar, str._pChar);
	}

	~String() {
		delete[] _pChar;
		_pChar = nullptr;
	}

	String& operator=(const String& str) {
		if (this == &str) {
			return *this;
		}
		delete[] _pChar;//需要释放掉自身占用的外部资源

		_pChar = new char[strlen(str._pChar) + 1];
		strcpy(_pChar, str._pChar);
		return *this;
	}

private:
	char* _pChar;

};

五、掌握构造函数的初始化列表

初始化列表和写在构造体里有什么区别:

初始化列表会直接定义并且赋值;放在构造体里会先执行定义操作,在对定义好的对象赋值。

对象变量是按照定义的顺序赋值的,与构造函数中初始化列表的顺序无关。上图中的ma是0xCCCCCCCC,mb是10,ma未赋值。

六、掌握类的各种成员方法及其区别

普通成员方法和常成员方法,是可以重载的,常成员方法可以在对象声明为const的时候调用。

对象声明为const的时候,调用成员方法是通过const对象的指针调用的,而普通的成员方法默认生成的是普通的指针对象,不能直接赋值。

只要是只读操作的成员方法,一律实现成const常成员方法

三种成员方法:

七、指向类成员的指针

class Test {
public:
	void func() { cout << "call Test::func" << endl; }
	static void static_func() { cout << "call Test::static_func" << endl; }

	int ma;
	static int mb;
};

int Test::mb=0;

int main() {
	Test t1;
	Test *t2 = new Test();//在堆上生成对象,并用指针指向

	//使用指针调用类成员方法(前面要加类的作用域Test::)
	void (Test:: * pfunc)() = &Test::func;
	(t1.*pfunc)();
	(t2->*pfunc)();

	//定义指向static的类成员方法
	void(*pfunc1)() = &Test::static_func;
	(*pfunc1)();

	//使用指针指向类成员变量,前面要加类的作用域Test::
	int Test::* p = &Test::ma;
	t1.*p = 20;
	cout << t1.*p << endl;

	t2->*p = 30;
	cout << t2->*p << endl;

	int* p1 = &Test::mb;
	*p1 = 40;
	cout << *p1 << endl;

	delete t2;
	return 0;
}

输出为:

总结

到此这篇关于C++面向对象之类和对象那些你不知道的细节原理的文章就介绍到这了,更多相关C++类和对象的原理内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C++类和对象深入探索之分文件编写点和圆的关系详解

    目录 创建圆心类 创建圆类 判断点圆关系函数 最终实现 总结 上一篇封装直达 创建圆心类 point.h #pragma once #include<iostream> using namespace std; //创建圆心类 class Point { public: void setM_x(int x); int getM_x(); void setM_y(int y); int getM_y(); private: int m_x; int m_y; }; 把圆心的横纵坐标设为私有,公共

  • C++深入探索类和对象之封装及class与struct的区别

    目录 封装的意义 访问权限 class和struct的区别 成员属性私有 案例练习 封装的意义 封装是C++三大面向对象之一 意义: 1.设计类的时候,属性和行为写在一起,表现事物 2.类在设计时,可以把属性和行为放在不同的权限下,加以控制 语法:class 类名 {访问权限:属性 / 行为}: 示例1:设计一个直角三角形,并求解他的面积 #include<iostream> using namespace std; //class代表设计一个类,后面跟着的是类名 class taiAngle

  • C++深入探究类与对象之友元与运算符重载

    目录 友元 1 全局函数做友元 2 类做友元 3 成员函数做友元 运算符重载 1 加号运算符重载 2 左移运算符重载 3 递增运算符重载 4 赋值运算符重载 5 关系运算符重载 6 函数调用运算符重载 友元 生活中你的家有客厅(Public),有你的卧室(Private),客厅所有来的客人都可以进去,但是你的卧室是私有的,也就是说只有你能进去,但是呢,你也可以允许你的好闺蜜好基友进去. 在程序里,有些私有属性也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术. 友元的目的就是让一个函数

  • C++深入探究类与对象之对象模型与this指针使用方法

    目录 C++对象模型和this指针 1 成员变量和成员函数分开存储 2 this指针概念 3 空指针访问成员函数 4 const修饰成员函数 C++面向对象的三大特性为:封装.继承.多态 C++认为万事万物都皆为对象,对象上有其属性和行为 例如: ​ 人可以作为对象,属性有姓名.年龄.身高.体重…,行为有走.跑.跳.吃饭.唱歌… ​ 车也可以作为对象,属性有轮胎.方向盘.车灯…,行为有载人.放音乐.放空调… ​ 具有相同性质的对象,我们可以抽象称为类,人属于人类,车属于车类 C++对象模型和th

  • C++浅析类与对象的基础

    目录 面向过程和面向对象 类的引入 访问限定符 封装 类的作用域 类的实例化 面向过程和面向对象 类和对象是 C++ 的核心特性 我们之前的C语言就属于面向过程,关注过程,分析求解问题的步骤再通过函数调用解决问题:而现在C++是基于面向对象,关注对象,将一个问题拆分成不同对象,依靠对象之间的交互完成. 比如有一个图书馆系统,用C语言面向过程思路就是:统计图书,图书分类,同步上架图书数据,记录借阅信息.而面向对象我们会创建两个类,图书馆和用户,我们关心的是图书馆和用户之间的关系,再分别实现交互,这

  • C++中的类与对象深度解析

    目录 初始化列表 引论 初始化列表 explicit关键字 引论 explicit关键字使用 static成员 友元 引论 友元 内部类 基础概念 内部类的使用 补充 析构顺序例题 总结 初始化列表 引论 //初始化列表的引出 class B { public: B() { cout << "我是B的构造函数" << endl; } private: int _b; }; class A { public: A() { cout << "我

  • C++初阶教程之类和对象

    目录 类和对象<上> 1. 类的定义 2. 类的封装 2.1 访问限定修饰符 2.2 类的封装 3. 类的使用 3.1 类的作用域 3.2 类的实例化 4. 类对象的存储 5. this 指针 5.1 this 指针的定义 5.2 this 指针的特性 类和对象<中> 1. 构造函数 1.2 构造函数的定义 2.2 构造函数的特性 2. 析构函数 2.1 析构函数的定义 3. 拷贝构函数 3.1 拷贝构造函数的定义 3.2 拷贝构造函数的特性 4. 运算符重载 4.1 运算符重载的

  • C++深入讲解类与对象之OOP面向对象编程与封装

    目录 1.面向对象编程 2.面向过程性编程和面向对象编程 3.类的引入 4.类的定义 4.1类的两种定义方式 4.1.1声明和定义全部放在类体中 4.2.2.声明和定义不放在类体中 5.类的访问限定符及封装 5.1 访问限定符 5.2封装 6.类的作用域 7.类的实例化 8.类对象模型 如何计算类对象的大小 面向过程编程也叫结构化编程.虽然结构化编程的理念提高了程序的清晰度,可靠性,并且方便维护.但它再编写大型的程序时,仍然面临这巨大的挑战,OOP(面向对象编程)提供了一种新的方法.与强调算法的

  • C++学习笔记之类与对象详解

    目录 前言: 1.访问限定符: [问题]C++中 struct和class的区别是什么? 2.封装 [问题]在类和对象的阶段,我们只研究类的封装特性,那什么是封装呢? 3.类的定义与声明 [问题]函数调用的问题 4.类的作用域 5.类的实例化 6.类的分类 总结 前言: 1.C 语言是面向过程的,关注的是过程,分析出求解的步骤,通过函数逐步调用解决问题. 2.C++是基于面向对象的,关注的是对象,蒋一件事情拆分成不同的对象,靠对象之间的交互完成. 举个例子:外卖系统 面向过程是下单.接单.送餐的

  • C++面向对象之类和对象那些你不知道的细节原理详解

    目录 一.类和对象.this指针 二.掌握构造函数和析构函数 三.掌握对象的深拷贝和浅拷贝 四.类和对象应用实践 五.掌握构造函数的初始化列表 六.掌握类的各种成员方法及其区别 总结 一.类和对象.this指针 OOP语言的四大特征是什么? 抽象 封装.隐藏 继承 多态 类体内实现的方法会自动处理为inline函数. 类对象的内存大小之和成员变量有关 类在内存上需要对齐,是为了减轻cup在内存上的io次数 查看类对象的大小的指令:cl className.cpp /d1reportSingleC

  • Javascript对象及Proxy工作原理详解

    正文 这一章其实算是javascript的科普文章,其实这本书的读者一般都不会是入门者,因此按道理说应该不需要再科普才对.但是作者依旧安排了这一章,证明就是这一章内容与我们以为的对象不一样. Javascript中一切皆对象 这一句话大家应该耳熟能详,对于常规的字面量对象,和new出来的对象,大家应该都能分辨 const str = '' const str2 = new String() const obj = {} const obj2 = Object.create() 但是根据ECMA,

  • JavaScript面向对象程序设计中对象的定义和继承详解

    本文实例讲述了JavaScript面向对象程序设计中对象的定义和继承.分享给大家供大家参考,具体如下: 在面向对象的Javascript编程中,希望代码优雅有高效是非常重要的.javascript中不存在类的概念,只有对象.要想把Javascript代码写的像java 或者C++一样优雅,就得考虑如何去实现,同时也要考虑性能和高效.定义javascript对象的方式有很多,继承的方式也很多.通过不断地实践,推荐如下的方法: 1.Javascript对象的定义采用混合方式[构造函数 +原型方式(p

  • C#面向对象编程中依赖反转原则的示例详解

    在面向对象编程中,SOLID 是五个设计原则的首字母缩写,旨在使软件设计更易于理解.灵活和可维护.这些原则是由美国软件工程师和讲师罗伯特·C·马丁(Robert Cecil Martin)提出的许多原则的子集,在他2000年的论文<设计原则与设计模式>中首次提出. SOLID 原则包含: S:单一功能原则(single-responsibility principle) O:开闭原则(open-closed principle) L:里氏替换原则(Liskov substitution pri

  • PHP面向对象五大原则之接口隔离原则(ISP)详解

    本文实例讲述了PHP面向对象五大原则之接口隔离原则(ISP).分享给大家供大家参考,具体如下: 设计应用程序的时候,如果一个模块包含多个子模块,那么我们应该小心对模块做出抽象.设想该模块由一个类实现,我们可以把系统抽象成一个接口.但是要添加一个新的模块扩展程序时,如果要添加的模块只包含原系统中的一些子模块,那么系统就会强迫我们实现接口中的所有方法,并且清寒要编写一些哑方法.这样的接口被称为肚胖接口或者被污染的接口,使用这样的接口将会给系统引入一些不当的行为,这些不当的行为可能导致不正确的结果,也

  • PHP面向对象五大原则之开放-封闭原则(OCP)详解

    本文实例讲述了PHP面向对象五大原则之开放-封闭原则(OCP).分享给大家供大家参考,具体如下: 1. 什么是"开放-封闭" 随着软件系统规模的不断增大,软件系统的维护和修改的复杂性不断提高,这种困境促使法国工程院士Bertrand Meyer在1998年提出了"开放-封闭"(Open-Close Principle,OCP)原则,这条原则的基本思想是: Open(Open for extendtion)模块的行为必须是开放的.支持扩展的,而不是僵化的. Close

  • PHP面向对象五大原则之单一职责原则(SRP)详解

    本文实例讲述了PHP面向对象五大原则之单一职责原则(SRP).分享给大家供大家参考,具体如下: 单一职责原则(Single Pesponsibility Principle, SRP) 单一职责有两个含义: 一个是避免相同的职责分散到不同的类中, 别一个是避免一个类承担太多职责 为什么要遵守SRP呢? (1)可以减少类之间的耦合 如果减少类之间的耦合,当需求变化时,只修改一个类,从而也就隔离了变化:如果一个类有多个不同职责,它们耦合在一起,当一个职责发生变化时,可能会影响到其他职责. (2)提高

  • PHP面向对象五大原则之依赖倒置原则(DIP)详解

    本文实例讲述了PHP面向对象五大原则之依赖倒置原则(DIP).分享给大家供大家参考,具体如下: 什么是依赖倒置呢?简单地讲就是将依赖关系倒置为依赖接口,具体概念如下: 1.上层模块不应该依赖于下层模块,它们共同依赖于一个抽象(父类不能依赖子类,它们都要依赖于抽象类) 2.抽象不能依赖于具体,具体应该要依赖于抽象. 注意,这里的接口不是狭义的接口. 为什么要依赖接口?因为接口体现对问题的抽象,同时由于抽象一般是相对稳定的或者是相对变化不频繁的,而具体是易变的.因此依赖抽象是实现代码扩展和运行期内绑

  • PHP面向对象五大原则之里氏替换原则(LSP)详解

    本文实例讲述了PHP面向对象五大原则之里氏替换原则(LSP).分享给大家供大家参考,具体如下: 替换原则由MIT计算机科学实验室的Liskov女士在1987年的OOPSLA大会上的一篇文章中提出,主要阐述有关继承的一些原则,故称里氏替换原则. 2002年,Robert C.Martin出版了一本名为<Agile Software Development Principles Patterns and Practices>的书,在书中他把里氏替换原则最终简化成一句话:"Subtypes

  • java面向对象设计原则之里氏替换原则示例详解

    目录 概念 实现 拓展 概念 里氏替换原则是任何基类出现的地方,子类一定可以替换它:是建立在基于抽象.多态.继承的基础复用的基石,该原则能够保证系统具有良好的拓展性,同时实现基于多态的抽象机制,能够减少代码冗余. 实现 里氏替换原则要求我们在编码时使用基类或接口去定义对象变量,使用时可以由具体实现对象进行赋值,实现变化的多样性,完成代码对修改的封闭,扩展的开放.如:商城商品结算中,定义结算接口Istrategy,该接口有三个具体实现类,分别为PromotionalStrategy (满减活动,两

随机推荐