首页 / C++ / 【C++深度解析】12、构造函数与拷贝构造函数

// 12-1.cpp
#include<stdio.h>
class Test
{
private:
    int i;
    int j;
public:
    Test(int newi, int newj)
    {
        printf("Test() Begin\n");
        i = newi;
        j = newj;
    }
    int getI() {return i;}
    int getJ() {return j;}
};
int main()
{
    Test t1(1, 2);
    printf("t1.i = %d\n", t1.getI());
    printf("t1.j = %d\n", t1.getJ());
    return 0;
}

2.1 构造函数重载

构造函数可以根据需要定义参数
一个类中可以存在多个重载的构造函数，遵循 C++ 重载的规则

注意：对象定义和声明不同

对象定义：申请对象的空间并调用构造函数
对象声明：告诉编译器存在这样一个对象

【C++深度解析】12、构造函数与拷贝构造函数 - 文章图片
编程实验：构造函数重载

// 12-2.cpp
#include<stdio.h>
class Test
{
public:
    Test()
    {
        printf("Test()\n");
    }
    Test(int v)
    {
        printf("Test(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);				// 初始化
    printf("i = %d\n", i);
    return 0;
}

2.2 手动调用构造函数

一般情况下，构造函数在对象定义时被自动调用，一些特殊情况下，需要手动调用构造函数。

编程实验：手动调用构造函数

// 12-3.cpp
#include<stdio.h>
class Test
{
private:
    int m_value;
public:
    Test()
    {
        m_value = 0;
        printf("Test()\n");
    }
    Test(int v)
    {
        m_value = v;
        printf("Test(v), v = %d\n", v);
    }
    int getvalue()
    {
        return m_value;
    }
};
int main()
{
    Test ta[3] = {Test(), Test(1), Test(2)};
    for (int i = 0; i < 3; i++)
    {
        printf("ta[%d].getvalue() = %d\n", i, ta[i].getvalue());
    }
    Test t = Test(100);
    printf("t.getvalue() = %d\n", t.getvalue());
    return 0;
}

类有两个构造函数，一个有参数，一个没有参数。main() 函数中定义了一个数组 ta[3]，我们指定数组的第一个元素调用没有参数的构造函数，后两个调用有参数的构造函数。

Test t = Test(100); 也是指定构造函数的一种方法。

编译运行：

$ g++ 12-3.cpp -o 12-3
$ ./12-3
Test()
Test(v), v = 1
Test(v), v = 2
ta[0].getvalue() = 0
ta[1].getvalue() = 1
ta[2].getvalue() = 2
Test(v), v = 100
t.getvalue() = 100

2.3 开发数组类解决原生数组安全性问题

需求：开发一个数组类解决原生数组的安全性问题

提供函数获取数组长度
提供函数获取数组元素
提供函数设置数组元素

直接看代码，IntArray.h 用于定义类，IntArray.cpp 用于类成员函数的实现。

// IntArray.h
#ifndef _INTARRAY_H_
#define _INRARRAY_H_
class IntArray
{
private:
    int m_length;
    int* m_pointer;
public:
    IntArray(int len);
    int length();
    bool get(int index, int& value);
    bool set(int index, int value);
    void free();
};
#endif

#include"IntArray.h"
IntArray::IntArray(int len)
{
    m_pointer = new int[len];
    for (int i = 0; i < len; i++)
    {
        m_pointer[i] = 0;
    }
    m_length = len;
}
int IntArray::length()
{
    return m_length;
}
bool IntArray::get(int index, int& value)
{
    bool ret = (index >= 0 && index < m_length);
    if (ret)
    {
        value = m_pointer[index];
    }
    return ret;
}
bool IntArray::set(int index, int value)
{
    bool ret = (index >= 0 && index < m_length);
    if (ret)
    {
        m_pointer[index] = value;
    }
    return ret;
}
void IntArray::free()
{
    delete[]m_pointer;
}

// 12-4.cpp
#include<stdio.h>
#include"IntArray.h"
int main()
{
    IntArray a(5);
    for (int i = 0; i < a.length(); i++)
    {
        a.set(i, i+1);
    }
    for (int i = 0; i < a.length(); i++)
    {
        int value = 0;
        if (a.get(i, value))
        {
            printf("a[%d] = %d\n", i, value);
        }
    }
    a.free();
    return 0;
}

$ g++ 12-4.cpp IntArray.cpp -o 12-4
$ ./12-4
a[0] = 1
a[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5

3 拷贝构造函数

两个特殊的构造函数

无参构造函数
- 当类中没有定义构造函数时，编译器默认提供一个无参构造函数，函数体为空
拷贝构造函数
- 参数为 const class_name&，当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制

// 12-5.cpp
#include<stdio.h>
class Point
{
public:
	Point(int xx = 0, int yy = 0)
	{
		x = xx;
		y = yy;
	}
	Point(const Point& p)
	{
		x = p.x;
		y = p.y;
		printf("Calling the copy constructor\n");
	}
	int getX(){ return x; }
	int getY(){ return y; }
private:
	int x;
	int y;
};
//形参为Point类对象的函数
void fun1(Point p) {
	printf("p.getX() = %d\n", p.getX());
}
//返回值为Point类对象的函数
Point fun2() {
	Point a(1, 2);
	return a;
}
int main() {
	Point a(4, 5);
	Point b = a; 			//情况一，用A初始化B。第一次调用拷贝构造函数
	printf("b.getX() = %d\n", b.getX());
	fun1(b); 				//情况二，对象B作为fun1的实参。第二次调用拷贝构造函数
	b = fun2(); 			//情况三，函数的返回值是类对象，函数返回时调用拷贝构造函数
	printf("b.getX() = %d\n", b.getX());
	return 0;
}

Calling the copy constructor
b.getX() = 4
Calling the copy constructor
p.getX() = 4
Calling the copy constructor
b.getX() = 1

3.1 深拷贝与浅拷贝

对于简单的类，默认的拷贝构造函数一般就够用了。但是当类持有其它资源时，例如动态分配的内存、指向其他数据的指针等，默认的拷贝构造函数就不能拷贝这些资源了，我们必须显式地定义拷贝构造函数，以完整地拷贝对象的所有数据。

例如，类 Point 中有一个指针变量在构造函数中申请空间，在析构函数中释放空间，如果用浅拷贝，p1 和 p2 中的指针指向的是同一块地址空间，析构时 delete 这块内存两次会出错。

采用深拷贝时，重新分配一块同样大小的内存，并将数据拷贝下来，这样 p1 和 p2 各自指向自己的数据块，析构时释放各自的内存。

编译器提供的拷贝构造函数只进行浅拷贝

【C++深度解析】12、构造函数与拷贝构造函数 - 文章图片

// 12-5.cpp
#include<stdio.h>
class Point
{
public:
    Point(int v, int xx = 0, int yy = 0)
    {
        p = new int;
        *p = v;
        x = xx;
        y = yy;
    }
    Point(const Point& pp)
    {
    	p = new int;
    	*p = *pp.p;
        x = pp.x;
        y = pp.y;
    }
    int getX(){ return x; }
    int getY(){ return y; }
    int* getP(){ return p; }
    ~Point(){ delete p; }
private:
    int* p;
    int x;
    int y;    
};
int main() {
    Point p1(3);
    Point p2(p1);
    printf("p1.x = %d, p1.y = %d, p1 = %p\n", p1.getX(), p1.getY(), p1.getP());
    printf("p2.x = %d, p2.y = %d, p2 = %p\n", p2.getX(), p2.getY(), p2.getP());
	return 0;
}

$ g++ 12-6.cpp -o 12-6
$ ./12-6
p1.x = 0, p1.y = 0, p1 = 0x5653bc52fe70
p2.x = 0, p2.y = 0, p2 = 0x5653bc52fe90

从运行结果看到，两个指针指向的内存是不一样的。

3.2 什么时候需要深拷贝？

当对象中有成员使用了系统中的资源时

成员指定了动态内存空间
成员打开了外存中的文件
成员使用了系统中的网络接口

一般原则：自定义拷贝构造函数，必然需要实现深拷贝！！！

3.3 数组类改进

由于前面实现的数组类中动态的申请了空间，这里增加拷贝构造函数实现深拷贝。

// IntArray.h
#ifndef _INTARRAY_H_
#define _INRARRAY_H_
class IntArray
{
private:
    int m_length;
    int* m_pointer;
public:
    IntArray(int len);
    IntArray(const IntArray& obj);
    int length();
    bool get(int index, int& value);
    bool set(int index, int value);
    ~IntArray();
};
#endif

#include"IntArray.h"
IntArray::IntArray(int len)
{
    m_pointer = new int[len];
    for (int i = 0; i < len; i++)
    {
        m_pointer[i] = 0;
    }
    m_length = len;
}
IntArray::IntArray(const IntArray& obj)
{
    m_length = obj.m_length;
    m_pointer = new int[obj.m_length];
    for (int i = 0; i < obj.m_length; i++)
    {
        m_pointer[i] = obj.m_pointer[i];
    }
}

int IntArray::length()
{
    return m_length;
}
bool IntArray::get(int index, int& value)
{
    bool ret = (index >= 0 && index < m_length);
    if (ret)
    {
        value = m_pointer[index];
    }
    return ret;
}
bool IntArray::set(int index, int value)
{
    bool ret = (index >= 0 && index < m_length);
    if (ret)
    {
        m_pointer[index] = value;
    }
    return ret;
}
IntArray::~IntArray()
{
    delete[]m_pointer;
}

// 12-6.cpp
#include<stdio.h>
#include"IntArray.h"
int main()
{
    IntArray a(5);
    for (int i = 0; i < a.length(); i++)
    {
        a.set(i, i+1);
    }
    for (int i = 0; i < a.length(); i++)
    {
        int value = 0;
        if (a.get(i, value))
        {
            printf("a[%d] = %d\n", i, value);
        }
    }
    IntArray b = a;
    for(int i=0; i<b.length(); i++)
    {
        int value = 0;
        if( b.get(i, value) )
        {
            printf("b[%d] = %d\n", i, value);
        }
    }
    return 0;
}

4 小结

1、构造函数可以重载
2、对象定义时会触发构造函数的调用
3、可以手动调用构造函数
4、拷贝构造函数的浅拷贝与深拷贝

点赞
收藏
分享
- 文章举报

-出发- 发布了248 篇原创文章 · 获赞 115 · 访问量 9万+ 私信关注

内容总结

以上是互联网集市为您收集整理的【C++深度解析】12、构造函数与拷贝构造函数全部内容，希望文章能够帮你解决【C++深度解析】12、构造函数与拷贝构造函数所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/644146.html

来源：【匿名】

【上一篇】【OpenCV（C++）】图像的矩【下一篇】c++有个库什么的吗?

更多 ►

【【C++深度解析】12、构造函数与拷贝构造函数】教程文章相关的互联网学习教程文章

c++旧教材--p81(构造函数和析构函数)

源程序：#include <iostream>using namespace std;class Point{private: 　　int x,y;public: 　　Point(int=0,int=0); ~Point(); };Point::Point(int a,int b):x(a),y(b){ 　　cout<<"Initializing"<<a<<","<<b<<endl;}Point::~Point() //定义析构函数{ 　　cout<<"Destructor is active"<<endl;}void main(){ 　　Point *ptr=new Point[2]; 　　delete []ptr;}原文：https://www.cnblogs.com/duanqibo/p/12021953.html

C++构造函数【代码】

构造函数的工作是保证每个对象的数据成员具有合适的初始值。一、构造函数的定义（1）构造函数可以被重载。可以为一个类声明的构造函数的数量没有限制，只要每个构造函数的形参表是唯一的。（2）实参决定使用哪个构造函数。（3）构造函数自动执行。只要创建该类型的一个对象，编译器就运行一个构造函数。（4）构造函数不能声明为const。创建类类型的const对象时，运行一个普通构造函数来初始化该const对象。构造函数的工作是初始化该...

C++回顾之构造函数与析造函数

构造函数的概念 (1)构造函数是特殊的成员函数 (2)当创建类类型的新对象时，系统自动会调用构造函数 (3) 构造函数是为了保证对象的每个数据成员都被正确的初始化。创建构造函数的注意事项： (1) 函数名与类名相同； (2) 没有返回类型，返回类型也不能是void型 (3) 构造函数通常情况下声明为public，否则不能像其它成员函数那样被显示的调用 (4) 构造函数也可以声...

c++学习笔记——构造函数

构造函数定义：每个类都分别定义了它的对象被初始化的方式，类通过一个或几个特殊的成员函数来控制其对象的初始化过程，这些函数叫做构造函数。需要注意的几点：1：构造函数不能被声明为const的，当我们创建一个const对象时，直到构造函数完成初始化过程，对象才能真正取得其“常量”属性。因此构造函数在const对象的构造过程中可以向其写值。2：只有类中没有声明任何构造函数时，编译器才会自动地生成默认构造函数。（依据：如果一...

C++中拷贝构造函数

Dog.h文件#include <iostream> #include <string> using namespace std; #ifndef DOG_H #define DOG_H class Dog { private:string name;int age;static int count; public:void bark() {cout << Dog::name << " age:" << Dog::age << endl;};Dog() {cout << "deflut constractor" << endl;}Dog(string name, int age){Dog::name = name;Dog::age = age;Dog::count += 1;cout << "constractor" << endl;};Dog(const Dog & dog){co...

C++_派生类的构造函数及派生类和基类之间的特殊关系【代码】【图】

派生类和基类的概念及派生类构造函数的原理：创建一个叫做TableTennisPlayer的基类，记录会员的名字和是否有球桌。 1//声明一个基类 2class TableTennisPlayer3{4private:5string firstname;6string lastname;7bool hasTable;8 9public: 10 TableTennisPlayer(); 11void Name() const; 12bool HasTable() const {return hasTable;}; 13void ResetTable(bool v) {hasTable =v;}; 14} 1516//构造函数的定义17 TableTennisPlayer...

[C++]复制构造函数、赋值操作符与隐式类类型转换

问题：现有类A定义如下：class A{public: A(int a) //构造函数 { m_a = a; cout<<"constructor"<<endl; } A(const A &d) //复制构造函数 { m_a = d.m_a; cout<<"copy constructor"<<endl; } A& operator=(const A &oA) //重载赋值操作符 {...

vc++如何创建程序-构造函数【图】

如果给Animal带参，则提示没有缺省的构造函数了，缺省就是不带参数的改进：从子类当中向基类传递代参的，这样他就会给Animal传递400，300对一个常量来调用#include<iostream.h>//定义一个动物类class Animal{public: //添加参数,对于一个类来说，无论带参不带参，C++都不再提供构造函数了 Animal(int height,int weight) { cout<<"animal construct"<<endl; } //析构函数 ~Animal() { cout<<"animal construct"<<endl; } void ...

C++构造函数

C++中构造函数是特殊的成员函数，只要定义类的新对象就会执行构造函数，构造函数是保证每个对象的数据成员具有合适的初始值。构造函数特点：1）构造函数与类同名，不能指定返回类型，且不能声明为const函数，详见const的使用2）构造函数可以重载，所以可以有多个构造函数 sales_item(void) /*const*/;sales_item(istream &is /*= cin */);sales_item(const string & book ); //must const sales_item(const sales_item &org);3）调...

23、【C++基础】复制构造函数【代码】

拷贝构造函数拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：通过使用另一个同类型的对象来初始化新创建的对象。复制对象把它作为参数传递给函数。复制对象，并从函数返回这个对象。如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：clas...

C++的构造函数们

1.什么是构造函数?一种特殊的成员函数，创建一个对象时，系统需要调用对象的构造函数进行初始化，类似于OC的init方法2.构造函数的特点函数名与类名一样，书写格式：类名(参数列表)没有返回值，加上void也不行每个类都有一个默认的公共的无参构造函数，但只要额外增加了一个构造函数，系统将不提供默认的空构造函数构造函数可以重载，也就是说，可以提供多个构造函数3.构造函数的其他知识点如果对象是一个全局变量，那么它的构造函数...

C++构造函数：初始化的那些事

C++构造函数：初始化的那些事说起C++的构造函数，大家绝不会陌生，似乎老生常谈，我一度也这么认为，但是有时概念的不清晰也许会使我们陷入莫名的困惑，下面我们就来初步的探索一下C++构造函数中那些有关初始化的事。(vs2010) 1、默认的初始化想必大家都知道C++会在我们没有提供任何构造函数的情况下为我们提供默认的缺省的构造函数，而构造函数的作用无非两样，第一步分配空间，初始化成员变量。换句话说，当我们调...

[C++11] 默认构造函数

类通过一个特殊的构造函数来控制默认初始化过程，这个函数就是默认构造函数，默认构造函数无需任何实参。我们可以显示的定义默认构造函数也可以让编译器为我们生成默认构造函数。默认构造函数以如下规则初始化累的数据成员：如果存在类内初始值，用它来初始化成员。否则，默认初始化该成员。class Sales_data { public:std::string bookNo;unsigned units_sold = 0;double revenue = 0.0; };如上所示，因为Sales_data为units_sold和...

C++ 拷贝构造函数和重载赋值操作符相互调用分析 [转]【代码】

结论：从面相对象编程的角度考虑，拷贝构造函数调用重载赋值操作符，重载赋值操作符调用拷贝构造函数的写法都是没有意义的。应该避免。Don‘t try to implement one of the copying functions in terms of the other. Instead, put common functionality in a third function that both call.——Effective C++ Third Edition By Scott Meyers Item 12: Copy all parts of an object Things to Remember首先明确：拷贝构造函数的...

c++中构造函数和析构函数

一、构造函数的特点（1）构造函数是类的一个特殊的成员函数，函数名与类名相同；（2）构造函数的访问属性应该是公有（public）访问属性；（3）构造函数的功能是对对象进行初始化，因此在构造函数中只能对数据成员做初始化，这些数据成员一般为私有成员，在构造函数中一般不做初始化以外的事情；（4）构造函数可以在类内定义也可以在类外定义；（5）构造函数无函数返回类型。注意：是什么也不写，也不可写void；（6）在程序运行时，...

首页 / C++ / 【C++深度解析】12、构造函数与拷贝构造函数

【C++深度解析】12、构造函数与拷贝构造函数

内容导读

内容图文

文章目录

1 问题

2 构造函数

2.1 构造函数重载

2.2 手动调用构造函数

2.3 开发数组类解决原生数组安全性问题

3 拷贝构造函数

3.1 深拷贝与浅拷贝

3.2 什么时候需要深拷贝？

3.3 数组类改进

4 小结

内容总结

内容备注

内容手机端

【【C++深度解析】12、构造函数与拷贝构造函数】教程文章相关的互联网学习教程文章

构造函数 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程