并非从0开始的c++ day15

最新推荐文章于 2024-08-21 18:16:36 发布
最新推荐文章于 2024-08-21 18:16:36 发布
阅读量486 收藏 1
点赞数
分类专栏： c++学习 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mcyuuji/article/details/130024901
版权
文章介绍了C++编程中类的构造函数、析构函数和拷贝构造函数的概念和作用。通过点和圆的例子展示了如何定义和使用这些函数，强调了深拷贝和浅拷贝的区别，并给出了避免浅拷贝问题的解决方案。同时，讨论了对象的生命周期以及构造函数的调用规则。
摘要由CSDN通过智能技术生成

并非从0开始的c++ day15

点和圆的关系 案例

要求

创建一个点的类，要求能输入和输出点
创建一个圆的类，要求能输入和输出圆
要求创建一个方法，能比较点和圆的关系

点的类

.h文件中

#pragma once
class Point
{
public:
	void setX(int X);
	void setY(int Y);
	int getX();
	int getY();

private:
	int x;
	int y;
};

.cpp文件中

#include "Point.h"

void Point::setX(int X)
{
	x = X;
}
void Point::setY(int Y)
{
	y = Y;
}
int Point::getX()
{
	return x;
}
int Point::getY()
{
	return y;
}

在.cpp文件中要想调用.h文件中的成员变量，除了需要添加头文件，还需要在函数前加入作用域

圆的类

.h文件中

#pragma once
#include"Point.h"

class Circle
{
public:
	void setMHear(Point MHear);
	void setMHear(int x, int y);
	void setMR(int MR);
	Point getMHear();
	int getMR();
	void isPointAndCircle(Point &p);
private:
	Point mHear;
	int mR;
};

在.h文件中，因为圆需要有圆心，圆心也是一个点，所以这里直接引入点的类，在圆的类中之间以私有权限创建一个点的对象，以充当圆心

.cpp文件中

#include "Circle.h"
#include <iostream>
using namespace std;

void Circle::setMHear(Point p)
{
	mHear.setX(p.getX());
	mHear.setY(p.getY());
}

void Circle::setMHear(int x, int y)
{
	mHear.setX(x);
	mHear.setY(y);
}

void Circle::setMR(int MR)
{
	mR = MR;
}

Point Circle::getMHear()
{
	return mHear;
}

int Circle::getMR()
{
	return mR;
}

void Circle::isPointAndCircle(Point &p)
{
	double distance = pow(p.getX() - mHear.getX(), 2) + pow(p.getY() - mHear.getY(), 2);
	double tempR = pow(mR, 2);

	if (distance == tempR)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance < tempR)
	{
		cout << "点在圆内" << endl;
	}
	else {
		cout << "点在圆外" << endl;
	}
}

由于深拷贝和浅拷贝的区别，在传入点的形参建立圆心的对象时，我们不直接拷贝点，而是利用点里面的获取x和y来赋予圆心

在写比较函数时，要秉持高内聚低耦合的设计理念，将半径和两点距离分开写，别都堆在if语句中

全局

void G_isPointAndCircle(Circle& c, Point& p)
{
	//获取点和圆之间的距离
	double distance = pow(p.getX() - c.getMHear().getX(), 2) + pow(p.getY() - c.getMHear().getY(), 2);


	//半径的平方
	double tempR = pow(c.getMR(), 2);

	if (distance == tempR)
	{
		cout << "全局 点在圆上" << endl;
	}
	else if (distance < tempR)
	{
		cout << "全局 点在圆内" << endl;
	}
	else {
		cout << "全局 点在圆外" << endl;
	}
}

void test()
{
	Point p;
	p.setX(30);
	p.setY(40);

	Circle c;
	c.setMR(50);
	c.setMHear(0, 0);

	c.isPointAndCircle(p);

	c.setMHear(p);
	G_isPointAndCircle(c, p);
}

全局函数在写的时候由于不能直接调用类里的成员变量并直接获取它的值，所以需要两次get函数来获取。
传入参数时，记得要加&取地址符

构造函数与析构函数

构造函数与析构函数的作用

构造函数的作用是初始化成员变量
析构函数运行在对象销毁前
构造函数和析构函数都是编译器去调用的

当没有构造函数时，直接将成员变量赋值给全局变量，会报错

构造函数和析构函数的运行

在实例化对象时，内部做了两件事，分配空间(栈区)，调用构造函数进行初始化

class Maker {
public:
	//构造函数的作用是初始化成员变量，是编译器去调用的
	//无参构造
	Maker()
	{
		a = 10;
		cout << "构造函数" << endl;
	}

	//析构函数,在对象销毁前，编译器调用析构函数
	~Maker()
	{
		cout << "析构函数" << endl;
	}

public:
	int a;
};

void test01()
{
	//实例化对象，内部做了两件事，分配空间（栈区），调用构造函数进行初始化
	Maker m;
	int b = m.a;
	cout << b << endl;
}

在mian函数中调用test01函数时，实例化对象m后，会运行一次构造函数，打印一次构造函数，然后逐步执行下来，打印一次b的值，函数运行结束前，运行一次析构函数。
在main函数中，实例化一次对象，将其放在test01后面，在上述打印完成后，才会打印一次构造函数，然后运行至return0，主函数结束，然后出现输入任意键退出，退出后，打印一次析构函数，并关闭程序

有参构造和无参构造函数

//析构函数的作用
class Maker2
{
public:
	//有参构造
	Maker2(const char * name,int age)
	{
		cout << "有参构造" << endl;
		//从堆区空间申请
		pName = (char*)malloc(strlen(name) + 1);
		strcpy(pName, name);
		mAge = age;
	}

	void printMaker2()
	{
		cout << "name:" << pName << " age:" << mAge << endl;
	}
	
	~Maker2()
	{
		cout << "析构函数" << endl;
		//释放堆区空间
		if (pName != NULL)
		{
			free(pName);
			pName = NULL;
		}
	}

private:
	char* pName;
	int mAge;
};

构造函数分为有参构造和无参构造，
有参构造可以用malloc从堆区空间申请一块空间，我们都知道malloc完需要free掉，所以在这个类的析构函数中，我们可以写free函数

构造函数和析构函数的注意点

  1. 构造函数可以重构
class Maker3
{
public:
	//注意1：构造函数可以重构
	Maker3()//无参构造函数
	{

	}
	Maker3(int a)//有参构造函数
	{

	}
};
  1. 构造函数，析构函数必须是公有权限
    当构造函数私有时，实例化不了对象
    当析构函数私有时，会直接在写代码的阶段报错
  2. 有对象产生必然会调用构造函数，有对象销毁必然会调用析构函数
    有多少个对象产生就会调用多少次构造函数，有多少个对象销毁就会调用多少次析构函数
  3. 构造函数没有返回值，不能用void，构造函数可以有参数，析构函数没有返回值，不能用void，析构函数不能有参数

默认的构造函数和析构函数

class Maker
{
public :
	Maker()//默认的构造函数，函数体是空的
	{

	}
	~Maker()//默认的析构函数，函数体也是空的
	{

	}
	//编译器默认提供默认的构造函数和析构函数
	void printfMaker()
	{
		a = 100;
		cout << "a = " << a << endl;
	}
private:
	int a;
};

拷贝构造函数

什么是拷贝构造函数

class Maker
{
public:
	Maker()
	{
		cout << "无参构造函数" << endl;
		a = 20;
	}

	//拷贝构造函数
	Maker(const Maker &m)
	{
		cout << "拷贝构造函数" << endl;
		a = m.a;
	}

	//打印函数
	void printMaker()
	{
		cout << "a = " << a << endl;
	}
private:
	int a;
};

void test01()
{
	Maker m1;
	m1.printMaker();

	//用一个已有的对象去初始化另一个对象
	Maker m2(m1);
	m2.printMaker();
}

传入const Maker &m是为了不让类修改函数里面的传入的变量，所以只能引用传递不能值传递

编译器提供了默认的拷贝构造函数

默认拷贝构造函数进行了成员变量的简单拷贝

class Maker2
{
public:
	Maker2()
	{
		cout << "无参构造函数" << endl;
		a = 20;
	}

	//编译器提供了默认的拷贝构造函数
	//Maker2(const Maker2& m)
	//{
	//	//默认拷贝构造函数进行了成员变量的简单拷贝
	//	a = m.a;
	//}

	//打印函数
	void printMaker()
	{
		cout << "a = " << a << endl;
	}

private:
	int a;
};


void test02()
{
	Maker2 m1;
	m1.printMaker();

	//用一个已有的对象去初始化另一个对象
	Maker2 m2(m1);
	m2.printMaker();
}

拷贝构造函数中形参要用引用

因为用的是引用，所以不是本身，是别名

如果拷贝构造函数中的形参不是引用
/*
Maker3(const Maker3 m)//const Maker3 m = m1;
{
cout << “拷贝构造函数” << endl;
}

1.Maker3 m2(m1);
2.const Maker3 m = m1;
3.const Maker3 m(m1);
4.const Maker3 m = m1;
5.进入死循环
*/

class Maker3
{
public :
	Maker3(int Ma)
	{
		cout << "有参构造函数" << endl;
		ma = Ma;
	}
	Maker3(const Maker3 &m)
	{
		cout << "拷贝构造函数" << endl;
	}
private:
	int ma;
};

void test03()
{
	Maker3 m1(10);//调用有参构造

	Maker3 m2(m1);
}

构造函数的分类及调用

  1. 构造函数的分类：无参构造函数，有参构造函数，拷贝构造函数
  2. 类默认提供了哪些函数：默认的构造函数，默认的析构函数，默认的拷贝构造函数，默认的赋值函数
  3. 构造函数的调用
void test()
{
Maker m;//调用无参构造函数
Maker m1(10);//调用有参构造
Maker m2(m1);//调用拷贝构造

//不常用
Maker m4 = Maker(10);//调用的是有参构造函数
Maker m3 = m2 ;//调用拷贝构造
cout << "= = = = ="<<endl;
Maker m5 = 10;//Maker m5 = Maker(10);

Maker m6;
m6 = m5;//赋值操作
}

匿名对象

匿名对象的生命周期在当前行
如Maker();

注意：如果匿名对象由名字来接，那么就不是匿名对象

如Maker m1 = Maker();

拷贝构造函数调用的时机

  1. 对象以值方式给函数参数
void func(Maker m)//Maker m = m1;
{

}

void test01()
{
	Maker m1;
	func(m1);
}
  1. 用一个已有的对象去初始化另一个对象
void test02()
{
	Maker m1;
	Maker m2(m1);
}
  1. 函数的局部对象以值的方式从函数返回
    vs Debug 模式下，会调用拷贝构造，vs Release模式下不会调用拷贝构造
Maker func2()
{
	//局部对象
	Maker m;
	cout << "局部对象的地址" << &m << endl;
	return m;
}

void test03()
{
	Maker m1 = func2();

	cout << "m1对象的地址：" << &m1 << endl;
}

构造函数的调用规则

  1. 如果程序员提供了有参构造，那么编译器不会提供默认构造函数,但是会提供默认拷贝构造函数

void test01()
{
	//Maker m;//err

	//Maker m(10);//调用有参构造
	//Maker m2(m);//调用默认的拷贝构造函数
}
  1. 如果程序员提供了拷贝构造，那么编译器不会提供构造函数

void test02()
{
	//Maker m;
}

多个对象的拷贝和析构

  1. 如果类有成员对象，那么先调用成员对象的构造函数，再调用本身的构造函数，析构函数的调用顺序反之
  2. 成员对象的构造函数调用和定义顺序一样
  3. 注意，如果有成员对象，那么实例化对象时，必须保证成员对象的构造和析构能被调用
class BMW
{
public:
	BMW()
	{
		cout << "BMW有参构造" << endl;
	}

	~BMW()
	{
		cout << "BMW析构" << endl;
	}
};

class Buick
{
public:
	Buick()
	{
		cout << "Buick构造" << endl;
	}

	~Buick()
	{
		cout << "Buick析构" << endl;
	}
};

class Maker
{
public:
	Maker()
	{
		cout << "Maker构造" << endl;
	}

	~Maker()
	{
		cout << "Maker析构" << endl;
	}
private:
	BMW bmw;//成员对象
	Buick bui;//成员对象
};

初始化列表

初始化列表是调用成员对象的指定构造函数
注意1：初始化列表只能写在构造函数

class BMW2
{
public:
	BMW2(int a)
	{
		cout << "BMW有参构造2" << a << endl;
	}

	~BMW2()
	{
		cout << "BMW析构2" << endl;
	}
};

class Buick2
{
public:
	Buick2(int x, int y)
	{
		cout << "Buick构造2" << endl;
	}

	~Buick2()
	{
		cout << "Buick析构2" << endl;
	}
};

class Maker2
{
public:

	//Maker2() :bmw2(10)
	//{
	//	cout << "Maker构造2" << endl;
	//}
	Maker2(int a) :bmw2(a),bui2(10,20)
	{
		cout << "Maker构造2" << endl;
	}

	Maker2(const Maker& m2):bmw2(40),bui2(10,20)
	{
		cout << "Maker拷贝构造2" << endl;
	}

	~Maker2()
	{
		cout << "Maker析构2" << endl;
	}
private:
	BMW2 bmw2;//成员对象
	Buick2 bui2;//成员对象
};

注意2：如果使用了初始化列表，那么所有的构造函数都要写初始化列表

注意3：如果有多个对象需要指定调用某个构造函数，用逗号隔开

注意4：可以使用对象的构造函数传递数值给成员对象的变量

对象的深浅拷贝

  1. 默认的拷贝构造函数进行了简单的赋值操作（浅拷贝）
  2. 浅拷贝的问题
    同一块空间被释放多次
class Student
{
public:
	Student(const char* name, int Age)
	{
		pName = (char*)malloc(strlen(name) + 1);
		strcpy(pName, name);
		age = Age;
	}

	~Student()
	{
		cout << "析构函数" << endl;
		if (pName != NULL)
		{
			free(pName);
			pName = NULL;
		}
	}
public:
	char* pName;
	int age;
};

void test02()
{
	Student s1("小花", 18);
	Student s2(s1);//调用默认的拷贝构造函数

	cout << "s1 Name = " << s1.pName << " s1 age = " << s1.age << endl;
	cout << "s2 Name = " << s2.pName << " s2 age = " << s2.age << endl;
}
  1. 用深拷贝解决问题
    自己写拷贝构造函数
//深拷贝
Student(const Student &stu)
{
	cout << "重写的拷贝构造函数" << endl;
	//1.申请空间
	pName = (char*)malloc(strlen(stu.pName) + 1);
	//2.拷贝数据
	strcpy(pName, stu.pName);
	age = stu.age;
}
mcyuuji
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Teach_Yourself_Visual_C++_6_in_21_Day
01-21
### Visual C++ 6.0 自学指南：21天精通 #### 一、课程简介与目标 本书《Teach Yourself Visual C++ 6 in 21 Days》旨在帮助读者在21天内掌握Visual C++ 6的核心功能及其开发环境。通过本教程的学习，您将能够熟练...
java_in_one_day
03-22
在一天之内掌握Java编程语言可能是一项艰巨的任务，但并非不可能。Java是一种广泛使用的高级编程语言，以其“一次编写，到处运行”的跨平台特性而闻名。本教程“java_in_one_day”将带你快速入门，理解Java的核心...
并非从0开始的c++ day9
mcyuuji的博客
02-28 271
函数指针 指向函数入口地址的指针函数名 函数的入口地址函数指针写法：返回值类型 +（指针变量名）（形参列表）func();//函数指针 指向函数地址 int * p =(int *) - 775679270;pFunc();//先定义出函数的类型，在通过类型定义函数指针变量 typedef void(FUNC_TYPE)(int , char);//定义出一个函数类型，返回值是void，形参列表（int，char）；
并非从0开始的c++ day8
mcyuuji的博客
02-27 266
对打开文件进行写入时，若文件缓冲区的空间未被写入的内容填满，这些内容弄不会写到打开的文件中。只有对打开的文件进行关闭操作时，停留在文件缓冲区的内容才能写到改文件中，从而使文件完整。再者一旦关闭了文件，该文件对应的FILE结构将被释放，从而使关闭的文件受到保护，因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区。写文件时需要写fclose，因为可能有些数据留在写文件缓冲区，要是直接结束，可能会留这部分数据在里面没写进去，需要我们手动将其输出到文件。
并非从0开始的c++ day10
mcyuuji的博客
03-14 228
在编译预处理的时候，将程序中在该语句以后出现的所有的num都用100代替。在预编译是将宏名替换成字符串的过程称为“宏展开宏定义，只在宏定义的文件中起作用。宏名一般用大写，以便于变量区别宏定义可以是常数、表达式等宏定义不作语法检查，只有在编译被宏展开后的源程序才会报错宏定义不是c语言，不在行末加分号宏名有效范围为从定义到本源文件结束可以用#undef命令终止宏定义的作用域在宏定义中，可以引用已定义的宏名宏通过使用参数，可以创建外形和作用都与函数类似的类函数宏。
并非从0开始的c++ day12
mcyuuji的博客
03-30 440
C++语言在c语言的基础上添加了面向对象编程和泛型编程的支持。C++继承了c语言高效，简洁，快速和可移植的传统c语言代表的过程性语言c++在c语言基础上添加的类代表的面向对象语言C++模板支持的泛型编程const用来限制一个变量不允许改变，它将一个对象转换成一个常量Maker() //构造函数 {a = 100;} int a;//数据类型定义变量 //类实例化对象 const Maker ma;
并非从0开始的c++ day13
mcyuuji的博客
04-06 236
const 有类型，可进行编译器类型安全检查。#define无类型，不可进行类型检查const有作用域，而#define不重视作用域，默认定义处到文件结尾。如果定义在指定作用域下有效的常量，那么#define就不能用。128输入参数为ma时，可以检查数据类型。
并非从0开始的c++ day14
mcyuuji的博客
04-07 225
C++的函数在汇编时，会给函数取别名，C语言的不会，这时，如果C++来调用C语言的函数，C++会去找去了别名的函数，但是C语言没有取别名，这时会报错。编译器是通过调用函数时，传入的参数来判断调用重载的哪个函数，我们调用函数时，不需要写返回值，所以返回值不能成为函数重载的条件。上述代码中，值传递是不交换a和b的值，指针传递和引用传递都改变值，但是两者的原理并不一致，参考之前的笔记。函数重载的原理是在汇编时，给各个函数取别名，C语言不能重载的原因就是没有给函数取别名。是：允许函数名相同，这种现象叫函数重载。
并非从0开始的c++ day6
mcyuuji的博客
02-22 306
/ARRAY_TYPE是一个有5个int元素的数组的类型 ARRAY_TYPE * arrP = & arr;i < 5;i ++) {} }//可以使用，但是比较麻烦 printf("%d\n" , * arrp [ 0 ]);//语法：数组元素类型(*数组指针变量名称)[元素个数] int(* p) [ 5 ] = & arr;i < 5;i ++) {} }三种定义方法，第一种可读性最强。
并非从0开始的c++之旅 day4
mcyuuji的博客
02-16 338
memcpy可以复制a到buf的相应位置，若要访问该位置，需要在解引用p指针的时候，强制类型转换为int*通过指针找到对应的地址，可以直接修改这个地址的内容，而不需要改变指针。3、如果以字符串初始化，那么编译器默认会在字符串尾部添加"\0"即用n级指针形参，去间接修改了n-1级指针（实参）的值。2、字符数组部分初始化，剩余填0，不会出现乱码。在主调函数分配内存，被调函数使用。方法二，利用字符串指针 进行翻转。在被调函数中，分配在堆区内存。方法一，利用下标方式进行翻转。方法二，利用字符串指针。
并非从0开始的c++之旅 day2
mcyuuji的博客
02-14 307
将p指针类型改为char *型，这时增加p指针的值会使其会一个一个往前走，在输出时，因为我们需要的是4个字节的int类型的内容，故需要做强制类型转换，将其转换为int *类型。p一开始为NULL，参数p的值为传入p的地址，temp为堆区开辟的地址，解参数p后赋值temp，也就是将temp所含的地址赋予p，这样p就能直接指向temp所指向的堆。打印出来的结果为NULL，因为test中的p和函数的参数p属于同级指针，test的p为NULL时，同级指针无法改变他的值，若要改需要更高级的二级指针。
c语言试题及答案(20211006143151).pdf
10-06
2. C语言的描述：C语言程序总是从`main`函数开始执行，A选项正确。每个语句和数据声明的最后通常需要分号，但并非所有情况都必须，如复合语句或某些结构体声明，B选项错误。C语言的注释符确实以`/*`开始并以`*/`结束...
ECI惯性坐标系转ECEF地心地固坐标系
11-06
文件"JD2GAST.m"可能包含了从儒略日（Julian Day, JD）到格林尼治天文时（Greenwich Mean Sidereal Time, GMST）的转换函数。GMST是天文学中的一个重要时间量，它表示地球自转的角度，对于坐标转换非常关键。"JD2...
对比C语言学习PHP.pdf
09-30
文档中还可能包含了其他内置函数如printf、echo、year、month、day等，这些函数可以用于输出信息到浏览器或文件系统。 10. PHP中的特殊语法 如花括号{}在PHP中的使用，以及${}的使用，这对于字符串的处理和输出有...
C语言：文件（写入，读取）
最新发布
2301_80311224的博客
08-21 646
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
学习C语言 第十九天
zh060515的博客
08-21 633
指程序的行为在 C 语言标准中没有明确定义，因此可以表现为任何结果。当程序出现未定义行为时，可能会产生不可预测的结果，包括程序崩溃、数据损坏、安全漏洞，甚至可能看起来正常运行。比如比较两个 NaN（非数字）值是否相等，这是未定义的行为。
C++ IO流
weixin_64099089的博客
08-19 670
C++标准IO流，文件IO流，序列化和反序列化
QT C++上位机软件开发，相比较C#上位机软件开发，有哪些特点和区别
曾经的我也很优秀，现在的我一无所有。
08-20 380
在开发上位机软件时，选择使用Qt C++还是C#取决于多种因素，包括项目需求、团队技能、开发速度等因素。
C++编程入门：从零开始理解编程概念
"C++从零开始 - 介绍C++编程的基础知识，旨在帮助初学者理解编程概念和C++的核心要素，特别强调基础的重要性。" 在《C++从零开始》这个系列中，作者旨在帮助那些对电脑编程感兴趣的人快速进入C++的世界，尤其注重...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值