c++核心编程复习_Day3

已于 2024-04-06 19:55:34 修改
阅读量164 收藏
点赞数
文章标签： c++ 开发语言 后端
于 2022-01-26 13:18:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55858644/article/details/122584569
版权

构造和析构函数的语法

    1. 构造函数
      1. //没有返回值  不用写void
      2. //函数名 与 类名相同
      3. //可以有参数  ，可以发生重载
      4. //构造函数 由编译器自动调用一次 无须手动调用
    2. 析构函数
      1. //没有返回值   不用写void
      2. 函数名 与类名相同  函数名前 加 ~
      3. 不可以有参数 ，不可以发生重载
      4. 析构函数 也是由编译器自动调用一次，无须手动调用
  1. 构造函数的分类和调用
    1. 分类
      1. 按照参数分类： 有参  无参（默认）
      2. 按照类型分类： 普通  拷贝构造 ( const  Person & p  )
    2. 调用
      1. 括号法
      2. 显示法
      3. 隐式法
    3. 注意事项
      1. 不要用括号法 调用无参构造函数  Person p3();  编译器认为代码是函数的声明
      2. 不要用拷贝构造函数 初始化 匿名对象 Person(p3); 编译器认为 Person p3对象实例化  如果已经有p3  p3就重定义
    4. 匿名对象  特点： 当前行执行完后 立即释放

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

//构造函数分类
//按照参数分类： 无参构造(默认构造函数) 和 有参构造
//按照类型分类： 普通构造函数    拷贝构造函数
class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数调用" << endl;
	}

	Person(int age)
	{
		m_Age = age;
		cout << "Person的有参构造函数调用" << endl;
	}


	//拷贝构造函数
	Person(const Person &p )  
	{
		cout << "Person的拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
	}

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

	int m_Age;
	
};

//构造函数的调用
void test01()
{
	//Person p;

	//1、括号法
	//Person p1(10);
	//Person p2(p);

	//注意事项一 
	//不要用括号法 调用无参构造函数  Person p3();  编译器认为代码是函数的声明
	

	//2、显示法
	//Person p3 = Person(10); //有参构造
	//Person p4 = Person(p3); //拷贝构造

	//Person(10); //匿名对象  特点： 当前行执行完后 立即释放

	//cout << "aaa" << endl;

	//注意事项二
	//不要用拷贝构造函数 初始化 匿名对象 Person(p3); 编译器认为 Person p3对象实例化  如果已经有p3  p3就重定义

	
	//3、隐式法  
	Person p5 = 10; //Person p5 = Person(10);
	Person p6 = p5;



}

int main(){
	test01();
	//Person p(18);
	//Person p2(p);
	//cout << "p2的年龄： " << p2.m_Age << endl;


	system("pause");
	return EXIT_SUCCESS;
}

拷贝构造函数调用时机

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

class Person
{
public:
	Person()
	{
		cout << "Person的默认构造函数调用" << endl;
	}

	Person(int age)
	{
		m_Age = age;
		cout << "Person的有参构造函数调用" << endl;
	}


	//拷贝构造函数
	Person(const Person &p)
	{
		cout << "Person的拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
	}

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

	int m_Age;

};


//1、用已经创建好的对象来初始化新的对象
void test01()
{
	Person p1(18);

	Person p2 = Person(p1);

	cout << "p2的年龄：" << p2.m_Age<< endl;

}

//2、值传递的方式 给函数参数传值
void doWork(Person p)
{

}
void test02()
{
	Person p1(100);

	doWork(p1);

}

//3、以值方式 返回局部对象
Person doWork2()
{
	Person p;
	return p;
}

void test03()
{
	Person p = doWork2();
}

/*	
	编译器优化代码后 release版本代码类似以下：
	void doWork2( Person &p ){};

	Person p;
	doWork2(p);
*/



int main(){
	//test01();
	//test02();
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

构造函数调用规则

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

//1、编译器会给一个类 至少添加3个函数    默认构造（空实现）   析构函数（空实现）   拷贝构造（值拷贝）
//2、如果我们自己提供了 有参构造函数，编译器就不会提供默认构造函数，但是依然会提供拷贝构造函数
//3、如果我们自己提供了 拷贝构造函数，编译器就不会提供其他构造函数
class Person
{
public:

	Person()
	{
		cout << "默认构造函数调用" << endl;
	}

	Person(int age)
	{
		m_Age = age;
		cout << "有参构造函数调用" << endl;
	}

	Person(const Person &p)
	{
		m_Age = p.m_Age;
		cout << "拷贝构造函数调用" << endl;
	}

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

	int m_Age;
};

void test01()
{
	Person p1;//提供拷贝构造后，要自己提供默认构造，否则出错
	p1.m_Age = 20;

	Person p2(p1);

	cout << "p2的年龄为： " << p2.m_Age << endl;

}


int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

深拷贝浅拷贝

  1. 深拷贝与浅拷贝的问题以及解决
    1. 如果有属性开辟到堆区，利用编译器提供拷贝构造函数会调用浅拷贝带来的析构重复释放堆区内存的问题
    2. 利用深拷贝解决浅拷贝问题
    3. 自己提供拷贝构造函数，实现深拷贝

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

class Person
{
public:

	Person( char * name ,int age )
	{
		m_Name = (char *) malloc(strlen(name) + 1);

		strcpy(m_Name, name);

		m_Age = age;
	}

	Person(const Person&p)
	{
	   m_Name =(char*)malloc(strlen(p.m_Name) + 1);
	   strcpy(m_Name, p.m_Name);
	   m_Age = p.m_Age;
	}

	~Person()
	{
		if (m_Name != NULL)
		{
			cout << "Person析构调用" << endl;
			free(m_Name);
			m_Name = NULL;
		}
	}

	char * m_Name; //姓名
	int m_Age;     //年龄
};


void test01()
{
	Person p("德玛西亚", 18);
	cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;

	Person p2(p);
	cout << "姓名： " << p2.m_Name << " 年龄： " << p2.m_Age << endl;
}

int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

初始化列表

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

class Person
{
public:

	//Person(int a, int b, int c)
	//{
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//Person() :m_A(10), m_B(20), m_C(30)
	//{
	//}

	//构造函数名称后  ： 属性(值), 属性（值）...
	Person(int a, int b, int c) : m_A(a), m_B(b), m_C(c)
	{
	}

	int m_A;
	int m_B;
	int m_C;
};

void test01()
{
	Person p(10, 20, 30);
	
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}

int main(){
	test01();


	system("pause");
	return EXIT_SUCCESS;
}

类对象中的类成员

  1. 类对象作为类中成员
    1. 当其他类对象 作为本类成员，先构造其他类对象，再构造自身，析构的顺序和构造相反
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
using namespace std;

class Phone
{
public:
	Phone(string pName)
	{
		cout << "Phone有参构造" << endl;
		m_PhoneName = pName;
	}

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

	string m_PhoneName;
};

class Game
{
public:
	Game(string gName)
	{
		cout << "Game有参构造" << endl;
		m_GameName = gName;
	}

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

	string m_GameName;
};

class Person
{
public:

	Person(string name,string pname,string gname):m_name(name),m_phone(pname),m_game(gname)
	{
		cout << "Person有参构造" << endl;
	}


	~Person()
	{
		cout << "Person析构函数" << endl;
	}
	string m_name;
	Phone m_phone;
	Game m_game;
};

void test01()
{
	Person p("张三", "OPPO", "LOL");
}

int main()
{


	test01();


	system("pause");
	return EXIT_SUCCESS;
}

 explicit关键字

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

class MyString
{
public:
	MyString(char * str)
	{
	
	}
	//explicit用途： 防止利用隐式类型转换方式来构造对象
	explicit MyString(int len)
	{
		
	}

	
};

void test01()
{


	MyString str1(10);

	MyString str2 = MyString(100);

	//MyString str3 = 10; // "10"

}

int main(){

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

new delete

  1. new和delete
    1. malloc 和 new 区别
      1. malloc 和 free 属于 库函数     new 和delete属于 运算符
      2. malloc不会调用构造函数   new会调用构造函数
      3. malloc返回void* C++下要强转     new 返回创建的对象的指针
    2. 注意事项 不要用void*去接受new出来的对象,利用void*无法调用析构函数
    3. 利用new创建数组
      1. Person * pPerson = new Person[10];
      2. 释放数组时候  需要加[]
      3. delete [] pPerson;
    4. 堆区开辟数组，一定会调用默认构造函数
    5. 栈上开辟数组，可不可以没有默认构造,可以没有默认构造
蓝图_BP
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在构造函数中使用new时应注意的事项、析构函数调用
少想多做
05-01 6540
使用new初始化对象的指针成员时必须特别小心。tu
c++核心编程指南中文版
09-29
c++核心编程指南中文版
c++---构造函数以及new和delete的使用
m0_70495061的博客
12-22 704
构造函数、析构函数、new和delete的使用
[c++初阶]浅谈new和delete
m0_62572672的博客
08-10 340
new的功能和c语言的里的malloc类似。区别是malloc创建失败返回NULL，new失败抛出异常。delete和free类似。new[]是用来一次性创建多个对象的.delete[]是用来一次性释放多个对象的。要注意的一点是，创建的类型和释放的类型要一致，不然会出现报错的情况.对于内置类型而言，new和malloc的区别不大。new的主要作用在自定义类型上。new和delete的时候会自动调用构造函数和析构函数进行初始化和释放。...
new、delete与构造、析构函数的关系
2301_76371717的博客
10-19 116
小结 ：指针对象想要获得或释放内存空间，需要通过new和delete实现。而普通对象在实例时系统会自动调用构造，在程序运行结束时会自动调用析构函数。使用new与delete之后：同时也调用构造与析构函数。使用new与delete之前：未调用构造与析构函数。动态释放：delete 实现，为指针对象释放空间。new与构造函数、delete与析构函数的区别。动态建立：new 实现，为指针对象分配空间。一、指针对象的动态建立与释放。
C++中new的用法及显示调用析构函数
weixin_34175509的博客
07-08 534
最近被问到了C++内存池的问题，其中不免涉及到在指定内存地址调用对象构造函数以及显示调用对象析构函数的情况。 C++中new的用法 new是C++中用于动态内存分配的运算符，在C语言中一般使用malloc函数。 （1）plain new顾名思义就是普通的new，就是我们惯常使用的new。分配内存，调用构造函数，在C++中是这样定义的： 1 void* operator new(std::size...
高质量c++c编程指南_c++编程_
09-29
高质量C++编程指导，将对c++初学者进阶有很大帮助
C++ 网络编程_c++网络编程_C++网络编程_
10-02
C++程序设计语言　C++ 网络编程 规范
高质量 C++C 编程指南_C编程规范_高质量C++C编程指南_C++编程规范_
09-29
一些关于C/C++编程时需留意的规范，你可以从中找出你的一些一直习惯用的但隐含错误的方式编程行为，提高软件质量
WINDOWS核心编程_C++_
10-03
Windows编程核心教程，很有用的，如果你是做与Windows相关的工作
定位new的析构
x
09-27 232
#include &lt;new&gt; #include &lt;string&gt; const int BUFF_SIZE = 512; using namespace std; class testing{ string words; int num; public: testing(const string &amp;s = "testing",int n =0...
c++构造和析构、new/delete
qq_27751235的博客
07-25 108
4、用户在使用对象之前，必须记住对它初始化。构造函数不能显示调用初始化(构造函数是由编译器调用)，用户有可能忘记调用初始化函数。2、malloc返回一个void指针，c++不允许将void赋值给其他任何指针，必须强转。3、malloc可能申请内存失败，所以必须判断返回值来确保内存分配成功。创建对象和释放对象时，构造函数和析构函数自动调用，不需要人为调用。c的动态内存分配函数太复杂，容易令人混淆，是不可能接受的。1、程序员必须确定对象的长度。类对象作为另外一个类的成员。构造函数的分类及调用。
C++进阶--new 和 delete
BIT-WDD
04-14 1923
因为在构造函数中使用 new 申请了内存，当对象过期时，对应的成员 str 也将过期，但是删除对象可以释放对象本身占用的内存，却不能释放由 new 单独申请的内存，所以必须在析构函数中释放。b.创建对象之后，将会调用构造函数，此时才会如前所述，利用构造函数为成员 str、len 分配用于保护字符串数据的内存，并将字符串的地址赋值给 str；这里首先释放了成员指针在之前指向的内存，然后复制成员数据，而不仅仅是数据的地址，并返回一个指向调用对象的引用。注意 ：new 带 []，则 delete 必须带；
【二、new与delete详解】
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
02-20 1029
深度分析malloc/free与new/delete的区别、new/delete的使用。
C++构造函数的default和delete
热门推荐
一直走，不要回头
12-06 1万+
转自：https://blog.csdn.net/u010591680/article/details/71101737   C++11中，当类中含有不能默认初始化的成员变量时，可以禁止默认构造函数的生成， myClass()=delete;//表示删除默认构造函数 myClass()=default;//表示默认存在构造函数 当类中含有不能默认拷贝成员变量时，可以禁止默认构造函数的生成...
molloc/free和new/delete的区别
一条二哈
12-17 1046
malloc/free和new/delete的区别 malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。 不同的地方是： malloc和free是函数，new和delete是操作符 malloc申请的空间不会初始化，new可以初始化 malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可 malloc的返回...
C++中的默认函数与default和delete用法
rizhaolutong的专栏
11-03 911
一、类中的默认函数 a.类中默认的成员函数 1.默认构造函数 2.默认析构函数 3.拷贝构造函数 4.拷贝赋值函数 5.移动构造函数 6.移动拷贝函数 b.类中自定义的操作符函数 1.operator 2.operator& 3.operator&& 4.operator* 5.operator-> 6.operator-
c++理解析构函数
ayci54153的博客
04-27 472
析构函数有2种方式调用，一个是主动调用delete，另一个是根据RAII的规则，在对象的生命周期结束时自动析构。第一点没什么好说的，就简单讲下第二点。 对象的生命周期不等于是程序的生命周期，一般我们所谓的生命周期就是一个作用域，当变量或者对象离开这个作用域时就会自动析构。一般一对{}就是一个作用域，举个例子 int main() { for(int i=0; i&lt...
析构函数，new对象和delete对象笔记
qq_38158479的博客
12-01 922
// txj.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 #include "pch.h" #include <iostream> #include"time.h" using namespace std; int main() { //一： new对象和delete对象 //我们自己new的对象必须自己释放,否则会造成内存泄漏。 //它不会...
黑马程序员c++核心编程
最新发布
10-24
黑马程序员C++核心编程是一门针对C++语言的深入学习课程，主要包括C++基础语法、面向对象编程、模板、STL等内容。该课程通过理论讲解和实战演练相结合的方式，帮助学员深入理解C++语言的核心概念和编程思想，掌握C++...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值