day03 C++学习

最新推荐文章于 2024-08-30 21:23:55 发布
最新推荐文章于 2024-08-30 21:23:55 发布
阅读量53 收藏 1
点赞数 1
分类专栏： C++学习 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48988730/article/details/130355043
版权

文章目录

对象的构造与析构

创建一个对象时，常常需要作某些初始化的工作，例如对数据成员赋初值。注意，类的数据成员是不能在声明类时初始化的。
为了解决这个问题，C++编译器提供了构造函数(constructor)来处理对象的初始化。构造函数是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行

1.1类的构造和解析基础

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
using namespace std;

class Test
{
public:
	Test()  //无参数 构造函数
	{
		a = 10;  //作用完成对属性的初始化工作
		p = (char *)malloc(100);
		strcpy(p, "aaaaffff");
		cout<<"我是构造函数 被执行了"<<endl;
	}
	void print()
	{
		cout<<p<<endl;
		cout<<a<<endl;
	}
	~Test() //析构函数
	{
		if (p != NULL)
		{
			free(p);
		}
		cout<<"我是析构函数,被调用了" <<endl;
	}
protected:
private:
	int a ;
	char *p;
};

//给对象搭建一个舞台,研究对象的行为
void objplay()
{
	//先创建的对象 后释放
	Test t1;
	t1.print();

	printf("分隔符\n");
	Test t2;
	t2.print();
}
void main11()
{
	objplay();
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

1.2类的构造和解析基础



#include <iostream>
using namespace std;

class Test2
{
public:
	Test2()  //无参数构造函数
	{
		m_a = 0;
		m_b = 0;
		cout<<"无参数构造函数"<<endl;
	}
	
	Test2(int a)
	{
		m_a = a;
		m_b = 0;
	}

	Test2(int a, int b) //有参数构造函数   //3种方法
	{
		m_a = a;
		m_b = b;
		cout<<"有参数构造函数"<<endl;
	}

	//赋值构造函数 (copy构造函数) //
	Test2(const Test2& obj )
	{
		cout<<"我也是构造函数 " <<endl;
	}

public:
	void printT()
	{
		cout<<"普通成员函数"<<endl;
	}
private:
	int m_a;
	int m_b;
};

void main21()
{
	
	Test2 t1;  //调用无参数构造函数
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

//调用 调用有参数构造函数 3
void main22()
{
	//1括号法 
	Test2 t1(1, 2);  //调用参数构造函数  c++编译器自动的调用构造函数
	t1.printT();

	// 2 =号法
	Test2 t2 = (3, 4, 5, 6, 7); // = c+对等号符 功能增强  c++编译器自动的调用构造函数

	Test2 t3 = 5;

	//3 直接调用构造函数  手动的调用构造函数
	Test2 t4 = Test2(1, 2);   //匿名对象 (匿名对象的去和留) 抛砖 ....//t4对象的初始化
	//

	t1 =  t4;  //把t4 copy给 t1  //赋值操作 
	//对象的初始化 和 对象的赋值 是两个不同的概念 
	
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

1.3 显示初始化方案


#include <iostream>
using namespace std;


class Test3
{
public:
	void init(int _a, int _b)
	{
		a = _a;
		b = _b;
	}

protected:
private:
	int a;
	int b;
};


void main31()
{
	
	//类没有提供构造函数,c++编译器会自动给你提供一个默认的构造函数
	//类没有提供构造函数 copy构造构造函数, c++编译器会自动给程序员提供一个 默认的copy构造函数  = 
	Test3 t1; 
	int a = 10; 
	int b = 20;
	t1.init(a, b);

	Test3 tArray[3];
	tArray[0].init(1, 2);
	tArray[1].init(1, 2);
	tArray[2].init(1, 2);

	//
	Test3 t21;  t21.init(1, 2);
	Test3 t22;	t22.init(1, 2);
	Test3 t23;	t23.init(1, 2);

	//在这种场景之下 显示的初始化方案 显得很蹩脚
	Test3 tArray2[3] = {t21, t22, t23};

	//在这种场景之下,满足不了,编程需要
	Test3 tArray3[1999] = {t21, t22, t23};
	

	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

1.4copy的构造函数


#include <iostream>
using namespace std;

class Test4
{
public:
	Test4()  //无参数构造函数
	{
		m_a = 0;
		m_b = 0;
		cout<<"无参数构造函数"<<endl;
	}

	Test4(int a)
	{
		m_a = a;
		m_b = 0;
	}

	Test4(int a, int b) //有参数构造函数   //3种方法
	{
		m_a = a;
		m_b = b;
		cout<<"有参数构造函数"<<endl;
	}

	//赋值构造函数 (copy构造函数) //
	Test4(const Test4& obj )
	{
		cout<<"我也是构造函数 " <<endl;
		m_b = obj.m_b + 100;
		m_a = obj.m_a + 100;
	}

public:
	void printT()
	{
		cout<<"普通成员函数"<<endl;
		cout<<"m_a"<<m_a<<" m_a"<<m_b<<endl;
	}
private:
	int m_a;
	int m_b;
};

//1  赋值构造函数 用1个对象去初始化另外一个对象  
void main41()
{
	Test4 t1(1, 2);
	Test4 t0(1, 2);

	//赋值=操作 会不会调用构造函数
	//operator=()//抛砖
	t0 = t1; //用t1 给 t0赋值  到操作 和 初始化是两个不同的概念

	//第1种调用方法
	Test4 t2 = t1; //用t1来初始化 t2 
	t2.printT();
	
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

//第二种调用时机
void main44()
{
	Test4 t1(1, 2);
	Test4 t0(1, 2);

	Test4 t2(t1);  //用t1对象 初始化 t2对象 
	t2.printT();

	cout<<"hello..."<<endl;
	system("pause");
	return ;
}


#include <iostream>
using namespace std;


class Location 
{ 
public:
	Location( int xx = 0 , int yy = 0 ) 
	{ 
		X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ; 
	}

	//copy构造函数  完成对象的初始化
	Location(const Location & obj) //copy构造函数 
	{
		X = obj.X; Y = obj.Y;
	}
	~Location() 
	{ 
		cout << X << "," << Y << " Object destroyed." << endl ; 
	}
	int  GetX () { return X ; }		int GetY () { return Y ; }
private :   int  X , Y ;
} ;


//业务函数  形参是一个元素
void f(Location p)
{
	cout<<p.GetX()<<endl;
}

void playobj()
{
	Location  a(1, 2);
	Location  b = a;
	cout<<"b对象已经初始化完毕"<<endl;

	f(b); //b实参取初始化形参p,会调用copy构造函数
}

void main51()
{
	playobj();
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}




#include <iostream>
using namespace std;


class Location 
{ 
public:
	Location( int xx = 0 , int yy = 0 ) 
	{ 
		X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ; 
	}

	//copy构造函数  完成对象的初始化
	Location(const Location & obj) //copy构造函数 
	{
		X = obj.X; Y = obj.Y;
	}
	~Location() 
	{ 
		cout << X << "," << Y << " Object destroyed." << endl ; 
	}
	int  GetX () { return X ; }		int GetY () { return Y ; }
private :   int  X , Y ;
} ;

//g函数 返回一个元素 
//结论1 : 函数的返回值是一个元素 (复杂类型的), 返回的是一个新的匿名对象(所以会调用匿名对象类的copy构造函数)

//
//结论2: 有关 匿名对象的去和留
//如果用匿名对象  初始化 另外一个同类型的对象, 匿名对象 转成有名对象
//如果用匿名对象  赋值给 另外一个同类型的对象, 匿名对象 被析构

//
//你这么写代码,设计编译器的大牛们:
//我就给你返回一个新对象(没有名字 匿名对象)
Location g()
{
	Location A(1, 2);
	return A;
}

//
void objplay2()
{
	g(); 
}

//
void objplay3()
{
	//用匿名对象初始化m 此时c++编译器 直接把匿名对转成m;(扶正) 从匿名转成有名字了m
	Location m = g(); 
	printf("匿名对象,被扶正,不会析构掉\n");
	cout<<m.GetX()<<endl;;
}

void objplay4()
{
	//用匿名对象 赋值给 m2后, 匿名对象被析构
	Location m2(1, 2);
	m2 = g();
	printf("因为用匿名对象=给m2, 匿名对象,被析构\n");
	cout<<m2.GetX()<<endl;;
}
void main()
{
	//objplay2();
	//objplay3();
	objplay4();
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

1.5 构造函数调用规则的研究


#include <iostream>
using namespace std;

class Test
{
public:
	
// 	Test(const Test& obj) //copy构造函数 作用: 用一个对象初始化另外一个对象
// 	{
// 		a = obj.a + 100;
// 		b = obj.b + 100;
// 	}

// 	Test(int _a, int _b)
// 	{
// 		;
// 	}
	Test()
	{

	}
	
	void printT()
	{
		cout << "a:" << a << "b: "<<b<< endl; 
	}

protected:
private:
	int a;
	int b;
};

//当类中定义了拷贝构造函数时，c++编译器不会提供无参数构造函数
//当类中定义了有参数构造函数是,c++编译器不会提供无参数构造函数

//在定义类时, 只要你写了构造函数,则必须要用

void main81()
{
	//Test t1; //调用无参构造函数
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

1.6 深拷贝与浅拷贝


#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
using namespace std;

//

class  Name
{
public:
	Name(const char *myp)
	{
		m_len = strlen(myp);
		m_p =(char *) malloc(m_len + 1); //
		strcpy(m_p, myp);
	}

	//Name obj2 = obj1;
	//解决方案: 手工的编写拷贝构造函数 使用深copy
	Name(const Name& obj1)
	{
		m_len = obj1.m_len;
		m_p = (char *)malloc(m_len + 1);
		strcpy(m_p, obj1.m_p);
	}

	~Name()
	{
		if (m_p != NULL)
		{
			free(m_p);
			m_p = NULL;
			m_len = 0;
		}
	}
protected:
private:
	char *m_p ;
	int m_len; 
};

//对象析构的时候 出现coredump
void objplaymain()
{
	Name obj1("abcdefg");
	//Name obj2 = obj1;  //C++编译器提供的 默认的copy构造函数  浅拷贝
	Name obj3("obj3");

	obj3 = obj1;  // C++编译器提供的 等号操作 也属 浅拷贝
}

void main91()
{
	objplaymain();
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

1.7 构造函数初始化列表


#include <iostream>
using namespace std;

class A
{
public:
	A(int _a)
	{
		a = _a;
		cout << "构造函数" << "a" << a << endl;
	}

	~A()
	{
		cout << "析构函数" << "a" << a << endl;
	}

protected:
private:
	int a;
};


//1 构造函数的初始化列表  解决: 在B类中 组合了一个 A类对象 (A类设计了构造函数)
//根据构造函数的调用规则 设计A的构造函数, 必须要用;没有机会初始化A
//新的语法  Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)
class B
{
public:
	B(int _b1, int _b2) : a1(1), a2(2), c(0)
	{

	}

	B(int _b1, int _b2, int m, int n) : a1(m), a2(n), c(0)
	{
		b1 = _b1;
		b2 = _b2;
		cout <<"B的构造函数"<<endl;
	}
	~B()
	{
		cout<<"B的析构函数" <<endl;
	}

protected:
private:
	int b1;
	int b2;
	A a2;
	A a1;
	const int c;
};


//2 先执行 被组合对象的构造函数 
//如果组合对象有多个,按照定义顺序, 而不是按照初始化列表的顺序

//析构函数 : 和构造函数的调用顺序相反

//3 被组合对象的构造顺序 与定义顺序有关系 ,与初始化列表的顺序没有关系.
//4 初始化列表 用来 给const 属性赋值 
void obj10play()
{
	
	//A a1(10);
	//B ojbB(1, 2);

	//1参数传递 
	B ojbB2(1, 2,3, 4);

	//2 调用顺序
	
	return ;
}

void main100()
{
	obj10play();
	system("pause");
}

1.8 构造中调用构造

#include "iostream"
using namespace std;


//构造中调用构造是危险的行为
class MyTest
{
public:
	MyTest(int a, int b, int c)
	{
		this->a = a;
		this->b = b;
		this->c = c;
	}

	MyTest(int a, int b)
	{
		this->a = a;
		this->b = b;

		MyTest(a, b, 100); //产生新的匿名对象
	}
	~MyTest()
	{
		printf("MyTest~:%d, %d, %d\n", a, b, c);
	}

protected:
private:
	int a;
	int b;
	int c;

public:
	int getC() const { return c; }
	void setC(int val) { c = val; }
};

int main()
{
	MyTest t1(1, 2);
	printf("c:%d", t1.getC()); //请问c的值是？
	system("pause");
	return 0;
}

1.9 new和delete基本用法和扩展


#include <iostream>
using namespace std;

// 1
//		malloc	free				c语言的函数
//		new		delete 操作符	c++的语法

//2		new 基础类型变量  分配数组变量  分配类对象

//3		

分配基础类型
void main01()
{
	// 
	int *p = (int *)malloc(sizeof(int));
	*p = 10;
	//free(p);
	delete p;

	int *p2 = new int; //分配基础类型
	*p2 = 20;
	free(p2);
	//
	int *p3 = new int(30);
	printf("*p3:%d \n", *p3);
	//delete p3;
	free(p3);

	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

//分配数组变量
void main02()
{
	//c语言分配数组
	int *p = (int *)malloc(sizeof(int) * 10);  //int array[10];
	p[0] = 1;
	//free(p);
	delete[] p;

	//c++分配数组 
	int *pArray = new int[10] ;
	pArray[1] = 2;
	//delete [] pArray; //数组不要把[] 忘记
	free(pArray);

	char *pArray2 = new char[25] ; //char buf[25]
	delete [] pArray2;


	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

class Test
{
public:
	Test(int _a)
	{
		a = _a;
		cout<<"构造函数执行" <<endl;
	}

	~Test()
	{
		cout<<"析构函数执行" <<endl;
	}

protected:
private:
	int a;
};

//分配对象new delete
//相同 和 不同的地方 new能执行类型构造函数   delete操作符 能执行类的析构函数

//	malloc 	free函数 C
//1 new 	delete 操作符号 c++的关键字
//结论
void main()
{
	//c 
	Test *pT1 = (Test *)malloc(sizeof(Test));
	//free(pT1);
	delete pT1;

	//c++
	Test *pT2 = new Test(10);
	//delete pT2;
	free(pT2);

	cout<<"hello..."<<endl;
	system("pause");
}

1-24 今天学到这里了，明天上午有面试，加油

鬼谷八荒伯特利
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习day02
qq_69809412的博客
05-17 256
c++学习的第二天
C++学习-Day-12
school751953的博客
05-27 291
C++学习-Day-12一、编程练习 一、编程练习 编写一个程序，读取键盘输入，直到遇到@为止，读取符号（数字除外）,将大写转换成小写，小写转换成大写。 #include<iostream> #include<cctype> int main() { using namespace std; char ch; int line=0; wh...
c++学习笔记 Day1
qq_52057773的博客
03-20 967
os：记录c++学习过程和踩坑，方便以后回顾。
C++学习笔记day3
qq_61100395的博客
03-31 1072
继承： 好处：减少重复代码 语法：class 子类：继承方式 父类 子类也称为派生类，父类也称为基类。 继承中的对象模型： 父类中所有的非静态成员都会被子类继承。 利用开发人员命令提示工具查看对象模型： 跳转盘符 C： 跳转文件路径 cd 具体路径下 查看命名 cl /d1 reportSingleClassLayout类名 文件名 继承中的构造和析构顺序： 先构造父类再构造子类 先析构子类再析构父类 继承中同名成员处理方式： 访问子类同名成员：直接访问即可 访问父类同名成员：需要加作用域 如果...
C++学习笔记day2
qq_61100395的博客
03-26 1472
类和对象： c++面相对象的三大特性为：封装，继承和多态。 封装的意义： 1.将属性和行为作为一个整体，表现生活中的事物。 2.将属性和行为加以权限控制。 访问权限： 1.public 公共权限： 成员类内可以访问，类外可以访问 2.protected 保护权限： 成员类内可以访问，类外不可以访问 （子类可以访问父类） 3.private 私有权限 成员类内可以访问，类外不可以访问 （子类不可以访问父类） struct和class的区别： struct默认权限为公共..
C++学习之C基础（day1）
10-02
根据给定的学习笔记内容，以下是对C语言基础知识的详细总结及解释： ### 第四章：语句 #### 4.1 空语句 - **定义**：空语句实际上仅由一个分号 `;` 构成，没有任何实际的操作。 - **示例**：`;` 或者 `int x; ;` ...
C++基础学习笔记 day03
Shallwen_Deng的博客
11-14 450
1.设计立方体类 设计立方体类（Cube），求立方体的面积（2*a*b + 2*a*c + 2*b*c）和体积（a*b*c），分别用全局函数和成员函数判断两个立方体是否相等？ #include <iostream> using namespace std; /* 设计立方体类（Cube） 求立方体的面积（2*a*b + 2*a*c + 2*b*c）和体积（a*b*c） 分...
Cplusplus in One Hour a Day；c++一天一小时
07-18
学习完基本的历史背景后，书中教授了如何编写、构建以及执行第一个C++程序，并指导如何理解编译器错误和调试程序。此外，书中还介绍了集成开发环境(IDE)的概念和使用。 课程接着深入到C++程序的剖析，解释了“Hello...
C++学习day08 ：lambda和异常捕获
qq_69809412的博客
05-24 413
C++学习第8天lambda的用法和异常捕获
C语言如何快速求值
2301_81985098的博客
08-26 1046
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数。一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？2、计算等式：m2 - n2 = (m + n)(m - n) = 168。1、则：x + 100 = n2, x + 100 + 168 = m2。6、由于 i * j = 168， j>=2，则。
c++命令模式
qq_71286244的博客
08-30 497
c++命令模式详细介绍
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 1737
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 3027
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 7383
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
【C++ 面试 - 内存管理】每日 3 题（三）
Newin2020的博客
08-26 1281
栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改。堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 1330
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++(Qt)-GIS开发-QGraphicsView显示瓦片地图简单示例2
最新发布
mahuifa的博客
08-30 630
支持多线程加载显示本地离线瓦片地图(墨卡托投影)； 瓦片切片规则以左上角为原点（谷歌、高德、ArcGis等），不支持百度瓦片规则； 支持显示瓦片网格、编号信息。 支持鼠标滚轮缩放切换地图层级。 支持鼠标拖拽。 采用z/x/y层级瓦片存储格式。 在单文件中实现所有主要功能，简单便于理解。 以北纬85.05，西经-180为坐标原点【绝对像素坐标】。
C++拷贝构造函数
m0_75109289的博客
08-30 146
设计一个Per类，类中包含私有成员:姓名、年龄、指针成员身高、体重，再设计一个Stu类，类中包含私有成员:成绩、Per类对象p1，设计这两个类的构造函数、析构函数和拷贝构造函数。
坐牢第三十天（c++）
m0_62828714的博客
08-27 2660
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++学习指南：一小时掌握基础
本书"C++ in One Hour a Day"是由Siddhartha Rao编写的Sams Teach Yourself系列教程，旨在帮助读者以高效的方式学习C++编程语言。本资源提供的是完整高清且带有目录的版本，适合自学C++的初学者使用。 在C++的自学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值