C++语言学习笔记4

最新推荐文章于 2024-07-20 18:10:49 发布
最新推荐文章于 2024-07-20 18:10:49 发布
阅读量174 收藏 1
点赞数 1
分类专栏： C++学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h0327x/article/details/123454393
版权

C++语言学习笔记4

五大对象的生命周期

#include <iostream>
using namespace std;


class CTest
{
public:
	CTest() {
		cout << "CTest()" << endl;
	}
	~CTest() {
		cout << "~CTest()" << endl;
	}
protected:
private:
};

CTest tst2;	//3. 全局对象 程序启动自动为对象分配空间，直到程序结束生命周期结束（看什么时候调用析构函数）

static CTest tst3;	//4. 静态全局对象 程序启动自动为对象分配空间，直到程序结束生命周期结束（看什么时候调用析构函数）

//全局对象和静态全局对象的区别：作用范围不同，静态全局对象为文件作用域，全局对象为整个项目工程。也就是说在两个源文件中，不可以重复定义两个名字类型一样的全局对象，但可以重复定义两个名字类型一样的静态全局对象

CTest* ptst = NULL;
void show() {
	static CTest tst;//生命周期 无论调用几次该函数，其都在第一次调用该函数的时候创建对象，直到程序结束，在内存中只有一份
	ptst = &tst;//取出tst的地址放在ptst这个指针里
}//无论运行多少遍这个函数，tst对象的地址都不会变

//5. 临时对象
CTest GetTest() {
	CTest tst;
	return tst;
}

int main() {

	//cout << "-------------------" << endl;
	//CTest tst;	//1. 局部对象（栈区），只在当前函数内生效，生命周期在函数结束时结束
	//
	//CTest* pTst = new CTest;	//2. new对象，生命周期需要delete才会结束

	show();

	CTest tst();
	调用无参构造时不要这样写，有时候编译器会误认为这是函数说明，应写：Ctest tst;
	//
	//cout << "-------------------" << endl;
	//CTest(2);//临时对象（匿名对象） 其生命周期只有当前这一行，遇到这一行的；以后就会被回收
	//cout << "-------------------" << endl;

	cout << "-------------------" << endl;
	GetTest();
	cout << "-------------------" << endl;

	system("pause");
	return 0;
}

类的初步认识

#include <iostream>
using namespace std;


class Ctest {
public:
	int m_a;
public:
	Ctest(int a) {
		m_a = a;
	}
	~Ctest() {
	
	}
	void show() {
	
	}
	void play() {
	
	}
};

int main() {

	//Ctest tst;
	//cout << sizeof(tst) << endl;
	//cout << sizeof(Ctest) << endl;	
	空类定义的对象的大小输出1  起到占位的作用，标识该对象在内存空间是真实存在的

	//Ctest tst;
	//cout << sizeof(tst) << endl;
	//cout << sizeof(Ctest) << endl;
	类中有int后，不再需要占位了，因为int的4个字节本身已经存在了，所以该大小输出为4而非5，不再需要加上占位的1
	类中写了两个空函数后依然输出4，能说明类成员属性占用对象的内存空间，定义对象时存在；类成员函数不占用对象的内存空间，其占用的是应用程序的内存空间，在编译期就存在（程序启用之前，嵌入在exe程序文件内）

	Ctest tst1(1);
	Ctest tst2(2);
	//断点调试中局部变量表中可以看到tst1中m_a是1，tst2中m_a是2，说明类成员属性中，两个对象在两个不同的内存空间中存在两份，也就是说多个对象存在多份，几个对象存在几份，但类成员函数并非如此，其属于类，不属于对象，因此只有一份

	system("pause");
	return 0;
}

this 指针

#include <iostream>
using namespace std;


class Ctest {
public:
	int m_a;
public:
	Ctest(int a) {
		m_a = a;
	}

	//this 指针 : CTest* const this;
	//类中非静态成员函数中有一个默认的隐含的参，this指针
	//this 指针：用于连接成员属性和成员方法的桥梁，哪个对象调用了函数this指针就指向哪个对象
	void show(/* CTest* const this */) {
		cout << m_a << endl;
		//cout << this->m_a << endl;
	}

	void play(/* CTest* const this */) {
		cout << "play()" << endl;
		//cout << m_a << endl;
	}

};

int main() {

	//Ctest tst1(1);
	//tst1.show();//将tst1这一对象的地址给this，然后对应输出this的m_a也就是tst1这一对象内定义的m_a的值为1
	//Ctest tst2(2);
	//tst2.show();//将tst2这一对象的地址给this，然后对应输出this的m_a也就是tst2这一对象内定义的m_a的值为2

	Ctest* p = NULL;
	//p->m_a = 10;	//程序崩溃
	p->play();	//没有对象，此时this指针为NULL，调用play这一函数时如果没有使用到成员变量m_a则可正常运行，但如果使用到m_a则程序崩溃，说明this这一指针确实链接了对象（成员变量）和该函数（成员方法）


	system("pause");
	return 0;
}

静态成员属性

#include <iostream>
using namespace std;

class CTest {
public:
	static int m_a;
	CTest() {
		cout << m_a << endl;
		m_a = 20;	//赋值
	}//	构造函数在创建对象的时候去执行，因此m_a = 10的初始化要等定义了对象再去初始化，但这与“静态成员属性不属于对象，属于类”相违背。而实际上此处并非初始化，而是初始化之后的一个赋值。
    
    //变量初始化指的是变量在定义的时候的赋值，而m_a这个变量作为staitc的静态成员属性，静态成员属性编译器就存在了，同时需要在类外进行初始化，因此等代码跑到m_a = 20这一行时，由于m_a已经定义初始化为20了，所以这一行只能是修改m_a的赋值
    
};

//类型 类名即作用域::变量名 = 初始化值
int CTest::m_a = 10;	//类外初始化，如果有多个类中都有m_a需要定义，那么需要作用域来区分，所以定义的时候需要有类名~

int main() {

	CTest tst;//定义对象时触发了构造函数，此时报错：无法解析外部符号m_a，也就是说m_a声明了但没有定义。而其不属于对象，所以应该在类外进行定义。（int CTest::m_a = 10;）

	cout << sizeof(CTest) << endl;	//输出1：说明依然占位，则静态成员属性不属于对象，属于类
	cout << CTest::m_a << endl;	//由于静态成员属性不属于对象，属于类，因此可以直接通过类名作用域来使用这一成员，比如CTest::m_a，当然以对象使用也可以，如下：cout<<tst.m_a<<endl;
	system("pause");
	return 0;
}

	//输出结果： 10 1 20（先类外初始化，然后进构造函数进行赋值）

静态成员变量

#include <iostream>
using namespace std;

class CTest {
public:
	static int m_a;
	CTest() {
		cout << m_a << endl;
	}
    
	void Show() {
		cout << m_a << endl;	//this->m_a
	}
};

int CTest::m_a = 10;

int main() {

	CTest tst1;
	cout << tst1.m_a << endl;
	tst1.m_a = 12;
	CTest tst2;
	cout << tst2.m_a << endl;
	//所有对象共享该静态成员变量，也就是说，其中一个对象改了后，其他的也会改

	system("pause");
	return 0;
}

	//输出结果： 10 10 12 12（输出顺序为tst1构造函数 tst1.m_a tst2构造函数 tst2.m_a）

静态成员函数

#include <iostream>
using namespace std;

class CTest {
public:
	static int m_a;
	int m_b;

	void Show() {
		cout << m_a << endl;	//this->m_a
		cout << m_b << endl;	//this->m_b
		this;
        CTest::play();
	}

	//静态成员函数
	//和普通函数一样，编译期就存在，属于类并只有一份，但两者最大的区别在于this指针
	//和静态成员变量一样，可以用对象去使用，也可通过类名作用域去使用
	static void play() {
		cout << "void play()" << endl;
		cout << m_a << endl;
		//cout << m_b << endl;//报错：对非静态成员CTest::m_b的非法引用
		//原因：静态成员函数在编译期就存在，不需要通过对象，但m_b此时根本不存在
		//this;//报错：this只能用于非静态成员函数的内部，也就是说，静态成员函数没有隐藏的this指针
		
	}
};

int CTest::m_a = 10;

int main() {

	CTest tst;
	tst.play();
	CTest::play();

	system("pause");
	return 0;
}

初始化参数列表

#include <iostream>
using namespace std;


class CTest {
public:
	const int m_a;
	int m_b;
	//初始化参数列表：真正的初始化
	CTest() :m_a(10), m_b(30) {//无参的初始化参数列表
		//m_a = 10;	
		//报错 此处为赋值 不是初始化 而const定义的是常量 所以不是可以修改的左值
		//m_b = 20;//普通变量可以这样初始化，也可以通过初始化参数列表进行真正的初始化，那么此处也可以等于是赋值
	}
};

int main() {

	CTest tst;
	cout << tst.m_a << endl;
	cout << tst.m_b << endl;

	system("pause");
	return 0;
}

初始化参数列表的初始化顺序

class CTest {
public:
	const int m_a;
	int m_b;

	//有参的初始化参数列表
	//初始化参数列表的初始化顺序：并不是写在参数列表中的顺序，而是变量在类中定义的顺序，也就是m_a,m_b
	//

	//CTest(int a) :m_a(m_b), m_b(a) {	//m_a没有初始化
	//	//用m_b去初始化m_a,但m_b的定义在m_a后，因此无法完成该初始化
	//}

	CTest(int a) :m_a(a), m_b(m_a) {

	}
};

const成员函数/常函数

#include <iostream>
using namespace std;


class CTest {
public:
	const int m_a;
	int m_b;
	CTest() :m_a(10), m_b(30) {
		
	}

	//const int show() {//返回值为常量（const int）
	//	
	//}


	void play(/*CTest* const this*/) {
	
	}

	//const成员函数（常成员函数):注意const要加在参数列表后面
	//常函数中可以使用 但不能修改
	int show (/* const CTest* const this */)const {
		//const修饰的是this指针，普通函数的this指针为CTest* const this，而常函数的为const CTest* const this
		cout << m_a << endl;
		cout << m_b << endl;

		//m_a = 20;
		//m_b = 20;
		//通过常量对象进行访问，因此无法修改

		return 0;
	}
};

int main() {

	CTest tst;
	tst.show();//普通对象可以调用普通函数和常函数

	//const CTest* const pp = &tst;	//指针的安全级别升级操作，是允许的
	//pp->m_a = 10;	//m_a无法修改，因为pp指针被const修饰了，也就是常函数隐含的const CTest* const this

	const CTest tst1;//常量对象：只能调用常函数，不可以调用普通函数
	tst1.show();

	//tst1.play();		//报错，无法调用
	//CTest* const p2 = &tst1;		//报错，为指针的安全级别降级操作，这是不被允许的

	system("pause");
	return 0;
}

类之间的横向关系

#include <iostream>
using namespace std;

//类之间的横向关系

class CFriend {
public:
	void play() {
		cout << "上号，开黑啦！" << endl;
	}

};

class CComputer {
public:
	void Complie() {
		cout << "正在编译代码呀~" << endl;
	}

};

class CHand {
public:
	void Move() {
		cout << "手 移动啦" << endl;
	}

};

class CPeople {
public:
	CHand m_hand;
	CFriend* m_pFriend;

	CPeople() {
		m_pFriend = NULL;
	}
	~CPeople() {
		
	}

	void Clap() {
		m_hand.Move();
		cout << "鼓掌拉 123 123 12333333" << endl;
	}
	void Code(CComputer* computer) {
		if (computer)
		{
			m_hand.Move();
			cout << "写代码啦 劈里啪啦" << endl;
			computer->Complie();
			cout << "生成可执行程序" << endl;
		}
	}

	void SetFriend(CFriend *pFriend) {
		m_pFriend = pFriend;
	
	}

	void PlayGame() {
		if (m_pFriend)
		{
			m_pFriend->play();
			cout << "五杀！" << endl;
		}
		else {
			cout << "朋友不理我了，孤儿自己开黑" << endl;
		}
	}

};

class CFamily {
public:
	CPeople* m_pPeople[10];
	CFamily() {
		for (int i = 0; i < 10; i++) 
		{
			m_pPeople[i] = NULL;
		}
	}
	~CFamily() {
		for (int i = 0; i < 10; i++)
		{
			if (m_pPeople[i])
			{
				delete m_pPeople[i];
				m_pPeople[i] = NULL;
			}
		}
	}

	void PushPeople(CPeople* pPeople) {
		for (int i = 0; i < 10; i++)
		{
			if (m_pPeople[i] == NULL) 
			{
				m_pPeople[i] = pPeople;
				return;	//	不写return的话会一直添加到第十个位置为止
			}
		}
	}

	void AllPeopleCode(CComputer* computer) {
		for (int i = 0; i < 10; i++) {
			if (m_pPeople[i])
			{
				m_pPeople[i]->Code(computer);
			}
		}
	
	}
};


int main() {
	
	//复合—————————————————————————————————————————————
	CPeople people1;
	people1.Clap();
	//————————————————————————————————————————————————


	//依赖—————————————————————————————————————————————
	CComputer* pComp = new CComputer;
	people1.Code(pComp);
	delete pComp;
	pComp = NULL;
	people1.Code(pComp);
	//————————————————————————————————————————————————
	

	//关联—————————————————————————————————————————————
	CFriend* pFriend = new CFriend;
	people1.SetFriend(pFriend);
	//people1.m_pFriend = pFriend;
	//不通过函数交朋友，直接通过成员变量赋值交朋友也是可行的
	people1.PlayGame();
	
	delete pFriend;
	pFriend = NULL;
	people1.m_pFriend = NULL;//朋友没了

	people1.PlayGame();
	//————————————————————————————————————————————————


	//聚合—————————————————————————————————————————————
	CFamily Workfamily;
	CPeople* pPeople1 = new CPeople;
	CPeople* pPeople2 = new CPeople;

	Workfamily.PushPeople(pPeople1);
	Workfamily.PushPeople(pPeople2);
	
	CComputer* pComp1 = new CComputer;
	Workfamily.AllPeopleCode(pComp1);

	//————————————————————————————————————————————————


	system("pause");
	return 0;
}
97Marcus
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2021-08-12c++考试题目
weixin_51516624的博客
08-12 1683
一、选择题（每题3分） 1.关于虚函数，正确的描述是() A 构造函数不能是虚函数 B 析构函数不能是虚函数 C 虚函数可以是友元函数 D 虚函数可以是静态成员函数 2.在32位操作系统g++编译器环境下，下面程序的运行结果为（） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ...
C++学习笔记（四）
JIWilliams
11-27 186
时间：2018/11/27 地点：元征总部 天气：多云                                                                                                         笔记 1.模板特殊化：当模板中的pattern有确定的类型时，模板有一个具体的实现。 （1）例如假设我们的类模板pair包含一个取模...
C++中复制构造函数与重载赋值操作符总结
WO的专栏
02-22 698
前言 这篇文章将对C++中复制构造函数和重载赋值操作符进行总结，包括以下内容： 1.复制构造函数和重载赋值操作符的定义； 2.复制构造函数和重载赋值操作符的调用时机； 3.复制构造函数和重载赋值操作符的实现要点 4.复制构造函数的一些细节。 复制构造函数和重载赋值操作符的定义 我们都知道，在C++中建立一个类，这个类中肯定会包括构造函数、析构函数、复制构造
复制构造函数问题
sunshineuuc的博客
09-08 528
#include #include using namespace std; int gid = 0; class ctest { public: ctest() { m_v = gid++; cout << m_v << "\tconstructor" << endl; } ctest(const ctest &v) { m_v = gid++; cout
C++试题5
u012093557的博客
09-23 269
12、若char是一字节，int是4字节，指针类型是4字节，代码如下： class CTest { public: CTest():m_chData(‘\0’),m_nData(0) { } virtual void mem_fun(){} private: char m_chData; int m_nData; static char s_chData; }; char CTes
C++深入学习笔记（15）—— 构造函数深探
慎铭的博客
10-12 111
使用构造函数初始值 有时候我们可以忽略成员初始化和赋值之间的差异，但是并非总是这样的，如果成员是const类型或者引用类型的话，必须将其初始化，如果成员为类类型切该类没有默认构造函数的话，那么也应当将其初始化，否则编译器会报错 class CTest { public: CTest(int i); private: int a; const int b; int &ra; } CTest::CTest(int i): a(i) {} // 错误，因为b和ra没有被初始化 CTest::C
C++机器学习笔记.md
08-24
内容概要： 本文介绍了使用C++编程语言实现机器学习算法的方法，包括线性回归、决策树和支持向量机（SVM）。每个算法都配有代码示例，详细展示了实现过程和关键思想。此外，文章还提供了两个示例，分别展示了如何...
C++学习笔记 C++学习笔记
08-06
【C++语言基础】 C++是一种强类型、面向对象的编程语言，遵循ANSI标准，具有高度的可移植性。它的程序由一系列指令组成，这些指令最终被编译成计算机可执行的二进制文件。在C++中，程序通常包含源代码文件，其扩展...
C++提高编程 学习笔记
05-11
### C++ 提高编程学习笔记：泛型编程与 STL 技术详解 #### 一、泛型编程概述 泛型编程是一种编程范式，通过在程序设计中使用参数化的类型来编写代码，使得同一段代码可以处理多种不同的数据类型。这种编程方式极大...
C++基础编程 学习笔记
05-13
C++基础编程，适合小白和跨专业的同学学习，涉及 C++介绍（注释，变量，关键字，标识符命名规则）、 数据类型（整型，sizeof关键字，实型（浮点型），字符型，布尔型，数据的输入）、 运算符（算数运算符，赋值...
C++ 核心编程学习笔记
07-02
C++这门语言语法和细节特别多，为了方便日后回忆记了些笔记。
C++成员变量的初始化顺序问题
wusecaiyun的专栏
10-06 375
问题来源： 由于面试题中，考官出了一道简单的程序输出结果值的题：如下， [cpp] view plaincopyprint? class A   {   private:       int n1;       int n2;          public:       A():n2(0),n1(n2+2){}     
C++学习笔记 第18课 对象的构造（中）
weixin_43824344的博客
07-19 103
1.构造函数 构造函数可以根据需要定义参数 一个类中可以存在多个重载的构造函数 友情提示： 对象的定义：申请对象的空间并调用构造函数 对象声明：告诉编译器存在这样一个对象 构造函数在定义对象时会自动调用 18-1 带参数的构造函数 #include <iostream> using namespace std; class cTest { public: cTest() { this->i = 1; cout << "cTest() begin" &
复习C++基础知识-----“我的第一本C++”读书笔记2
web开发
07-03 165
抽象一般分为属性抽象和行为抽象两种。前者寻找一类对象共有的属性或者状态变量，后者则寻找这类对象所具有的共同行为特征。在分析新的对象时，应该从属性和行为两个方面进行抽象和概括，提取对象的共有也行。有了抽象，那么就可以提取出来当做接口(虚函数)，可以直接变成类的成员属性和成员函数。 如何在子类中调用从父类继承并且已经被重写的函数？-------------------- #include "std...
C++刷题笔记（一）
MyLinChi的博客
10-20 1386
1.数组的初始化 int *p1=new int[10];该语句给指针p1分配内存，没有对指针初始化，  int *p2=new int[10]();该语句给指针p2分配内存，并初始化指针。 2.数组作为形参，实参会退化为指针 #include using namespace std; void example(char acWelcome[]){ cout << sizeof(
CTest
bacanpi5506的博客
12-03 1021
一、初识CTest CTest是CMake集成的一个测试工具，在使用CMakeLists.txt文件编译工程的时候，CTest会自动configure、build、test和展现测试结果 CTest有两个模式： 模式一：使用CMake configure 和 build工程，在CMakeLists.txt文件中，使用特殊的命令取创建tests。...
[学习笔记] C++ 历年试题解析（二）--程序题
weixin_30376323的博客
11-02 145
发现程序题也挺有价值的。 顺便记录下来几道。 1.题目 #include <iostream> #include <cstring> using namespace ① std ; void Swap(char * const str1, char * const str2) { // 形参为锁定目标的指针（即指针常量，亦...
C语言 之 理解指针（1）
最新发布
fallzzzzz的博客
07-20 1230
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
Java与C++对比学习笔记
Java基础 Java与C++在语言特性上有许多显著的区别，对于初学者来说，理解这些差异是掌握Java的关键。首先，Java没有指针的概念，而是...了解这些区别有助于更好地理解和使用Java，特别是在从C++背景转到Java学习时。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

97Marcus

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值