C++深度解析(11)—对象的初始化、浅拷贝、深拷贝、数组类的创建

最新推荐文章于 2024-06-22 16:56:46 发布
最新推荐文章于 2024-06-22 16:56:46 发布
阅读量637 收藏 2
点赞数 1
分类专栏： c++深度剖析 文章标签： 构造函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22847457/article/details/96424651
版权

1.对象的构造（上）

1.1 问题

  • 对象中成员变量的初始值是多少？
#include <stdio.h>

class Test
{
private:
	int i;
	int j;

public:
	int getI()
	{
		return i;
	}
	
	int getJ()
	{
		return j;
	}	
};

Test gt;  // 静态存储区

int main()
{
	printf("gt.i = %d\n", gt.getI());
	printf("gt.j = %d\n", gt.getJ());

	Test t1;  // 栈

	printf("t1.i = %d\n", t1.getI());
	printf("t1.j = %d\n", t1.getJ());

	Test* pt = new Test; // 堆

	printf("pt->i = %d\n", pt->getI());
	printf("pt->j = %d\n", pt->getJ());

	delete pt;

	getchar();
	
	return 0;
}
  • 运行结果

1.2 对象的初始化

  •  从程序设计的角度，对象只是变量，因此： 
    • 在栈上创建对象时，成员变量初始为随机值 
    • 在堆上创建对象时，成员变量初始为随机值 （gcc会为其赋0）
    • 在静态存储区创建对象时，成员变量初始为0值 
  • 问题： 程序中如何对—个对象进行初始化？
  • 一般而言，对象都需要—个确定的初始状态 
  • 解决方案 ：
    • 在类中提供—个public的initialize函数 
    • 对象创建后立即调用initialize函数进行初始化 
#include <stdio.h>  

class Test
{
private:
	int i;
	int j;

public:
	int getI() 
	{ 
		return i;
	}
	
	int getJ() 
	{ 
		return j;
	}

	void initialize()
	{
		i = 1;
		j = 2;
	}
};

Test gt;

int main()
{
	gt.initialize();

	printf("gt.i = %d\n", gt.getI());
	printf("gt.j = %d\n", gt.getJ());

	Test t1;

	//t1.initialize();  //若没有立即调用

	printf("t1.i = %d\n", t1.getI());
	printf("t1.j = %d\n", t1.getJ());

	t1.initialize();   //在此处调用

	Test* pt = new Test;
	pt->initialize();

	printf("t1.i = %d\n", t1.getI());
	printf("t1.j = %d\n", t1.getJ());
	printf("pt->i = %d\n", pt->getI());
	printf("pt->j = %d\n", pt->getJ());

	delete pt;

	getchar();

	return 0;
}
  • 运行结果

  • 存在的问题 
    • initialize只是—个普通函数，必须显示调用 
    • 如果未调用initialize函数，运行结果是不确定的 

1.3 构造函数

  • C++中可以定义与类名相同的特殊成员函数 ，这种特殊的成员函数叫做构造函数 
    • 构造没有任何返回类型的声明 
    • 构造函数在对象定义时自动被调用 
#include <stdio.h>  

class Test
{
private:
	int i;
	int j;

public:
	int getI() 
	{ 
		return i; 
	}
	
	int getJ() 
	{ 
		return j;
	}
	
	Test()
	{
		printf("Test() Begin\n");

		i = 1;
		j = 2;

		printf("Test() End\n");
	}
};

Test gt;

int main()
{
	printf("gt.i = %d\n", gt.getI());
	printf("gt.j = %d\n", gt.getJ());

	Test t1;

	printf("t1.i = %d\n", t1.getI());
	printf("t1.j = %d\n", t1.getJ());

	Test* pt = new Test;

	printf("pt->i = %d\n", pt->getI());
	printf("pt->j = %d\n", pt->getJ());

	delete pt;

	getchar();

	return 0;
}
  • 运行结果

1.4 小结

  • 每个对象在使用之前都应该初始化 
  • 类的构造函数用于对象的初始化 
  • 构造函数与类同名并且没有返回值 
  • 构造函数在对象定义时自动被调用 

2.对象的构造（中）

2.1 对象定义和对象声明不同 

  • 对象定义－申请对象的空间并调用构造函数 
  • 对象声明－告诉编译器存在这样—个对象 
Test t; //定义对象并调用构造函数  
  
int main()  
{  
      
    extern Test t;  //告诉编译器存在名为t的Test对象   
      
    return 0;  
} 

2.2 带参数的构造函数

  • 构造函数可以根据需要定义参数 
#include <stdio.h>

class Test
{
public:
	Test()
	{
		printf("Test()\n");
	}
	
	Test(int v)
	{
		printf("Tset(int v), v = %d\n", v);
	}
	
};

int main()
{
	Test t;  // 调用 Test()
	Test t1(1);  // 调用Test(int v) 
	Test t2 = 2;  // 调用Test(int v) 

	int i(100);  // 赋值, 注意C++中对象初始化和赋值差距
	
	printf("i = %d\n", i);
	
	getchar();

	return 0;
}
  • 运行结果：

2.3 构造函数的调用 

  •  一般情况下，构造函数在对象定义时被自动调用 
  •  一些特殊情况下，需要手工调用构造函数 
#include <stdio.h>

class Test
{
private:
    int i;
    int j;
    int k;
    
/*这种与类名相同的成员函数叫做构造函数
构造函数在定义时可以有参数，但是没有任何返回类型的声明
*/
public:
    Test(int v)
    {
        i = v;
        j = v;
        k = v;
    }
    
    void print()
    {
        printf("i = %d, j = %d, k = %d\n", i, j, k);
    }
};

int main()
{
    Test t1(4);    // 自动调用构造函数
    Test t2 = 5;    // 自动调用构造函数
    Test t3 = Test(6);   // 主动调用构造函数
    
    t1.print();
    t2.print();
    t3.print();
    
    Test tA[3] = {Test(4), Test(5), Test(6)};  // 主动调用构造函数
	
    for(int i = 0; i < 3; i++)
    {
        tA[i].print();
    }
    
    printf("Press any key to continue...");

    getchar();
    
    return 0; 
}
  • 运行结果

2.4 成员函数的重载

  • 类的成员函数和普通函数一样可以进行重载，并遵守相同的重载规则
#include <stdio.h>

class Test
{
private:
	int i;
	int j;
	int k;
    
public:
	Test()
	{
		i = 0;
		j = 0;
		k = 0;
	}
    
	Test(int v)
	{
		i = v;
		j = v;
		k = v;
}
    
void print()
{
    printf("i = %d, j = %d, k = %d\n", i, j, k);
}
    
void print(int v)
{
    printf("v = %d\n", v);
}
};

int main()
{
	Test t1(1);
	Test t2 = 2;
	Test t3 = Test(3);
	Test t4;
	Test t5;
    
	t5.print(5);
	t4.print();
	t1.print();
	t2.print();
	t3.print();


	printf("\n");
    
	Test tA[3] = { Test(5),6,7 };
    
	for(int i = 0; i < 3; i++)
	{
		tA[i].print();
	}
    
	printf("Press any key to continue...");
    
	getchar();
    
	return 0;
}
  • 运行结果

2.5 小结

  • 构造函数可以根据需要定义参数 
  • 构造函数之间可以存在重载关系 
  • 构造函数遵循C++中重载函数的规则 
  • 对象定义时会触发构造函数的调用 
  • 在—些情况下可以手动调用构造函数

3.对象的构造（下）

3.1 两个特殊的构造函数 

  • 无参构造函数：没有参数的构造函数 
    • 无参构造函数 ：当类中没有定义构造函数时，编译器默认提供—个无参构造函数，并且其函数体为空 
  • 拷贝构造函数：参数为const class_name&的构造函数
    • 当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制
#include <stdio.h>

class Test
{
private:
	int i;
	int j;
	int k;

public:
	Test()   // 当提供拷贝构造而不提供无参构造，编译器报错
	{
	
	}

	Test(const Test &t)  // 不写默认提供
	{
		i = t.i;
		j = t.j;
		k = t.k;
	}
	
	void print()
	{
		printf("i = %d, j = %d, k = %d\n", i, j, k);
	}
};

int main()
{
	Test t1;
	Test t2 = t1;

	t1.print();
	t2.print();

	printf("Press any key to continue...");
	
	getchar();
	
	return 0;
}
  • 运行结果：
  • 拷贝构造函数的参数不能用值传递，只能用引用。如果用值传递，在函数运行时，函数内部会产生一个新的副本（实参副本）接收实参的值（形参变量的值是实参变量的副本），从而又要调用拷贝构造函数，造成死循环。
  • 如果类中一个构造函数都没有写，则编译器自动提供无参构造函数和拷贝构造函数。但如果已经存在某种构造函数，但编译器不会提供无参构造函数，但任然会提供拷贝构造函数。

3.2 拷贝构造函数

  • 拷贝构造函数的意义 
    • 兼容C语言的初始化方式 
    • 初始化行为能够符合预期的逻辑
  • 浅拷贝 
    • 拷贝后对象的物理状态相同 
  • 深拷贝 
    • 拷贝后对象的逻辑状态相同 
  • 编译器提供的拷贝构造函数只进行浅拷贝！ 
#include <stdio.h>

class Test
{
private:
	int i;
	int j;
	int *p;

public:
	int getI()
	{
		return i;
	}

	int getJ()
	{
		return j;
	}

	int *getP()
	{
		return p;
	}

	Test(int v)
	{
		i = 1;
		j = 2;
		p = new int;

		*p = v;
	}

	void free()
	{
		delete p;
	}
};

int main()
{
	Test t1(3);
	Test t2 = t1;

	printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
	printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());

	//t1.free();
	//t2.free();
	
	getchar();
	
	return 0;
}
  • 运行结果：
  • 调用了默认拷贝构造函数，成员变量值一样，但当释放堆空间 t1.free();  t2.free(); 两次释放了堆空间的内存

  • 解决方案：增加拷贝构造函数，实现深拷贝
#include <stdio.h>

class Test
{
private:
	int i;
	int j;
	int *p;

public:
	int getI()
	{
		return i;
	}

	int getJ()
	{
		return j;
	}

	int *getP()
	{
		return p;
	}

	Test(int v)
	{
		i = 1;
		j = 2;
		p = new int;

		*p = v;
	}

	Test(const Test &t)
	{
		i = t.i;
		j = t.j;
		p = new int;

		*p = *t.p;
	}

	void free()
	{
		delete p;
	}
};

int main()
{
	Test t1(3);
	Test t2 = t1;

	printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());
	printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());

	printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());
	printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());

	t1.free();
	t2.free();
	
	getchar();
	
	return 0;
}
  • 运行结果：
  • 什么时候需要进行深拷贝？ 
    • 对象中有成员指代了系统中的资源 
    • 成员指向了动态内存空间 
    • 成员打开了外存中的文件 
    • 成员使用了系统中的网络端口 

   .......
-

3.3 数组类的创建

  • 需求：开发—个数组类解决原生数组的安全性问题 
    • 提供函数获取数组长度 
    • 提供函数获取数组元素 
    • 提供函数设置数组元素
  • 编程实验
  • Array.h
#ifndef _ARRAY_H_
#define _ARRAY_H_

class Array
{
private:
    int mLength;
    int *mSpace;

public:
    Array(int length);
    Array(const Array &obj);
    int length();     // 获取数组长度
    void setData(int index, int value);  // 设置数组元素
    int getData(int index);  // 获取数组元素 
    void destory();
};

#endif
  • Array.cpp
#include "Array.h"

Array::Array(int length)
{
	if (length < 0)
	{
		length = 0;
	}
	
	mLength = length;
	mSpace = new int[mLength];
}

Array::Array(const Array &obj)
{
	mLength = obj.mLength;
	mSpace = new int[mLength];

	for (int i = 0; i < mLength; i++)
	{
		mSpace[i] = obj.mSpace[i];
	}
}

int Array::length()
{
	return mLength;
}

void Array::setData(int index, int value)
{
	mSpace[index] = value;
}

int Array::getData(int index)
{
	return mSpace[index];
}

void Array::destory()
{
	mLength = -1;
	delete[] mSpace;
}
  • main.cpp
#include <stdio.h>
#include "Array.h"

int main()
{
	Array a1(10);  // 自动调用构造函数
    
	for(int i = 0; i < a1.length(); i++)
	{
		a1.setData(i, i);
	}
    
	for(int i = 0; i < a1.length(); i++)
	{
		printf("Element %d: %d\n", i, a1.getData(i));
	}
    
	printf("\n");
	
	Array a2 = a1;  // // 自动调用拷贝构造函数 
    
	for(int i = 0; i < a2.length(); i++)
	{
		printf("Element %d: %d\n", i, a2.getData(i));
	}
    
	a1.destory();
	a2.destory();
    
	printf("Press any key to continue...");
    
	getchar();
    
	return 0;
}
  • 运行结果

3.4 小结

  • C++编译器会默认提供构造函数 
  • 无参构造函数用于定义对象的默认初始状态 
  • 拷贝构造函数在创建对象时拷贝对象的状态 
  • 对象的拷贝有浅拷贝和深拷贝两种方式 
    • 浅拷贝使得对象的物理状态相同 
    • 深拷贝使得对象的逻辑状态相同 
小虾米_2018
关注
专栏目录
C++:浅拷贝的解决方法（深拷贝(传统写法,现代写法)，写时拷贝）
赫菲斯托斯，，
04-20 914
什么是浅拷贝？ 第一种方法：深拷贝（传统方法） 第二种方法：深拷贝（现代简洁方法） 第三中方法：写时拷贝
C++ 深度解析教程（六）对象的构造、初始化列表的使用
Exp.Joker
06-15 732
对象的构造（上）1、问题：对象中成员变量的初始值是多少？2、小实验：下面的类定义中成员变量i和j的初始值为什么?编程实验：成员变量的初始值3、对象的初始化4、构造函数 5、小结十八、对象的构造（中）1、构造函数注意：初始化和赋值是完全不一样的。2、小实例3、编程实验：数组类的实现4、小结十九、对象的构造（下）1、特殊的构造函数2、拷贝构造函数3、什么时候需要进行深拷贝？4、编程实验：数组类的改进IntArray.cIntArray.hmain.c5、小结二十、初始化列表的使用1、问题：类中是否可以定义...
C++中的对象初始化
weixin_33893473的博客
02-05 568
　　 当对象在创建时获得了一个特定的值，我们说这个对象被初始化。初始化不是赋值，初始化的含义是创建变量赋予其一个初始值，而赋值的含义是把当前值擦除，而以一个新值来替代。对象初始化可以分为默认初始化、直接初始化、拷贝初始化以及值初始化。   // （1）默认初始化 int i1;//默认初始化，在函数体之外(初始化为0) int f(void) { int i2...
c++11 统一初始化
weixin_42923076的博客
05-06 593
c++11 统一初始化 一、c++98/03的初始化方式 括号初始化 int a(2);//ctor(尽管这个例子貌似不是很恰当) int b(a);//c-ctor 列表初始化： //c++98/03的列表初始化用于初始化数组 int arr1[3] = { 1, 2, 3 }; int arr2[] = { 1, 3, 2, 4 }; //c++98/03的列表初始化用于初始化结构体变量（貌似不太常用） struct A{ int a; int b; int c; };
C++11新特性-----变长的对象初始化列表
居老师的博客
05-09 255
C++11 提供了 initializer_list 来接受变⻓的对象初始化列表： class A{ public: A(std::initializer_list<int> list); }; A a = {1, 2, 3}; 注意初始化列表特性只是现有语法增强，并不是提供了动态的可变参数。该列表只能静态地构造 c++11标准中，initializer_list对于标准库的编写影响非常大，说一个简单的例子，在c++11之前，max函数的源程序是这样的： template <
c++11：类内初始化
qq_41543888的博客
09-18 2453
类内初始化 在C++11，我么可以为类内成员变量提供一个初始值，则我们在创建对象的时候，这个初始值就用来初始化该成员变量。 enum LineStyle{ lsSolid, lsDash, lsDot, }; class Rect { public: Rect() :left{0}, top{0}, right{0}, bottom{0},style...
C++深度解析 对象的构造（下）---无参构造函数，拷贝构造函数，深拷贝，浅拷贝（18）
Tim的嵌入式之旅
12-24 566
C++深度解析 对象的构造（下）---无参构造函数，拷贝构造函数，深拷贝，浅拷贝（18）       特殊的构造函数 无参构造函数 当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空。 //经典的面试题，这个类里面有什么东西 //空类，里面至少有一个无参构造函数，编译器提供 class T { /* T() { } *...
【源码级深拷贝分析】：揭秘库函数背后的数据复制逻辑
![源码级深拷贝]...深拷贝则会复制对象及其所包含的所有成员变量，创建一个全新的对象，与原对象在内存中不共享任何内容。 ## 浅拷贝的
C++后台开发面试题总结(涉及C++基础、多线程多进程、网络编程等)
Linux高级开发的博客
03-11 6992
C++后台开发面试题总结(涉及C++基础知识、多线程多进程、TCP/IP网络编程、Linux操作、数据结构与算法) 因巩固知识体系，面试，梳理以往看到过的知识点，故总结如下相关题目，题目答案请自行google baidu，这里只提供题目。 一、C++基础知识面试题总结 1、多态的实现 2、说说C/C++的区别 3、const关键字 4、说说malloc/free 和 new/delete区别 5、指针和引用的区别 6、C++中堆和栈的区别 7、关键字static 8、在C++程序中调用被
C++中对象初始化方式
风轻淡淡的博客
03-18 9141
感谢原作者的辛勤劳作：https://blog.csdn.net/yang20141109/article/details/50374696 当对象在创建时获得了一个特定的值，我们说这个对象被初始化。初始化不是赋值，初始化的含义是创建变量赋予其一个初始值，而赋值的含义是把当前值擦除，而以一个新值来替代。 对象初始化可以分为默认初始化、直接初始化、拷贝初始化以及值初始化。 1，...
C++11类成员的初始化总结
AdairJun
05-02 2141
C++为类中提供类成员的初始化列表。 类对象的构造顺序是这样的： 1.分配内存，调用构造函数时，隐式／显示的初始化各数据成员 2.进入构造函数后在构造函数中执行一般计算   1.类里面的任何成员变量在定义时是不能初始化的。   2.一般的数据成员可以在构造函数中初始化。   3.const数据成员必须在构造函数的初始化列表中初始化。   4.static要在类的定义外面初始化。   
c\c++复习基础要点11----对象的浅拷贝和深拷贝
Y_23k_bug的专栏
10-04 1233
默认的拷贝构造函数与对象的浅拷贝问题   如果定义类时，没有为其声明拷贝构造函数，则编译器会为类自动生成一个拷贝构造函数，这个由编译器自动生成的拷贝构造函数称为默认的拷贝构造函数。默认的拷贝构造函数的功能就是把参数对象内容按字节拷贝给当前正在创建的对象。     对象的浅拷贝：   #include using namespace std;   class A {  pub
C++11:统一初始化
最新发布
m0_66182473的博客
06-22 838
初始化不是赋值。初始化：创建变量时赋予其一个初始值。赋值：把变量的当前值擦除，用一个新值替代。C++初始化有几种不同的形式，比如给int型变量x初始化,以下四个方式都可以。
C++学习——第11章 创建自己的数据类型
C的菜鸟
01-11 1192
1.       对象的感念 面向对象的编程方式就是根据问题所特定的对象类型来解决该问题，而不是采用计算机处理数字和字符的低级方式来解决问题。 在C++编程术语中，对象是数据类型的一个实例。例如：在定义一个变量时，常常使用下面的语句： string saying = “A good horse cannot be of a bad color.”; 这里定义
C++ 封装(3): 对象成员与对象数组, 深拷贝和浅拷贝
TechArtisan6的博客
03-18 1714
C++远征之封装篇（下）视频教程 笔记 方便自己查阅和复习，温故而知新。 目录 1 对象成员与对象数组 代码示例 2 深拷贝和浅拷贝 代码示例 3 对象指针 4 const 再现江湖 参考资料 1 对象成员与对象数组 如下图所示，定义坐标类, 通过不同坐标可以描述一个 矩形。 那么我们有两种方式去定义和访问它，如下图所示： 那么在内存中，...
C++11复制控制
C++ 爱好者 make_it_simple888
03-11 294
复制控制的内容 复制(拷贝)控制：拷贝构造、拷贝赋值、移动 构造、移动赋值、析构 一般来说，用户需要定义的场景是： 1 析构函数 =&gt; 拷贝 + 赋值 需要析构的类也基本上需要拷贝和赋值 2 拷贝&lt;=&gt;赋值 需要拷贝的类也需要赋值 3 default 我们要求编译器生成合成版本，这通常是值类型的类 4 delete阻止拷贝 被删除的函数是 指我们声明了这个...
C++拷贝构造函数(深拷贝，浅拷贝)
Sugar_Tiger[糖伯虎]的专栏
02-13 5721
 转自:本Blog停止更新,感谢原作者C++拷贝构造函数(深拷贝，浅拷贝) 对于普通类型的对象来说，它们之间的复制是很简单的，例如：int a=88;int b=a; 而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。 #include iostream>using namespace std;class CExample {pr
C++类对象的复制－拷贝构造函数(深拷贝，浅拷贝)
loop in codes
03-02 1528
以前我们的教程中讨论过函数返回对象产生临时变量的问题，接下来我们来看一下在函数中返回自定义类型对象是否也遵循此规则产生临时对象！ 先运行下列代码: //程序作者:管宁 //站点:www.cndev-lab.com //所有稿件均有版权,如要转载,请务必著名出处和作者 #include iostream>usingnamespacestd; classInternet { public: Int
C++集合初始化：简化数组和类对象创建
在C++中，集合初始化不仅限于数组，也可以用于集合类，如vector、set或map等，只需要在创建对象时提供相应的初始元素。 面向对象编程（Object-Oriented Programming，OOP）是C++的核心概念之一。它强调将数据和操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值