精华内容
下载资源
问答
  • C++中类的构造函数复制构造函数

    千次阅读 2017-04-27 10:52:42
    当程序运行时,编译器发现复制构造函数是public,则说明程序允许对象之间的复制,此时就会通过直接调用自定义构造函数来初始化对象,而不再调用复制构造函数,完成优化”。这位朋友还提到,如果将复制构造函数改为...

    1 相关定义

    1.1 构造函数

    构造函数是类的特殊的成员函数,只要创建类类型的新对象,都要执行构造函数。构造函数的工作是保证每个对象的数据成员具有合适的初始值。构造函数的名字与类的名字相同,并且不能指定返回类型。像其他任何函数一样,它们可以没有形参,也可以定义多个形参。

    1.2 复制构造函数

    复制构造函数是一种特殊构造函数,具有单个形参,该形参(常用const修饰)是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时,将显式使用复制构造函数。

    2 两种初始化方式

    C++支持两种初始化方式:直接初始化和复制初始化。

    2.1 两种初始化方式的实现

    复制初始化使用=符号,而直接初始化将初始化式放在圆括号中。

    自定义一个名为MyClass的类。并且定义MyClass类的默认构造函数、自定义构造函数和复制构造函数。

    class MyClass
    {
    public:
    MyClass()
    {
    cout << "进入MyClass的默认构造函数" << endl;
    }
    MyClass(const char* pc)
    {
    cout << "进入MyClass自定义构造函数" << endl;
    }
    MyClass(const ClassTest& ct)
    {
    cout << "进入MyClass复制构造函数" << endl;
    }
    };

    接下来使用直接初始化和复制初始化定义MyClass类的对象:

    MyClass mc1(“myclass”);
    MyClass mc2 = mc1;

    运行后的效果如图所示

     

    从上图可以看出,第1行代码调用了MyClass类的自定义构造函数,第2行代码调用了MyClass类的复制构造函数。

    2.2 两种初始化方式的关系

    对于MyClass类对象的定义,还有一种方式,如下所示

    MyClass mc3 = “myclass”;

    这种定义方式是采用了哪种初始化呢?《C++ Primer中文版第4版》P407页提到,以上这种定义方式,“编译器首先调用接受一个C风格字符串形参的构造函数,创建一个临时对象,然后,编译器使用复制构造函数将类的对象初始化为那个临时对象的副本”。也就是说,以上代码应该调用了MyClass类的两个构造函数,一个是自定义的参数为const char*的构造函数,一个是复制构造函数。然而,程序运行后的效果如图所示

     

    此时,只调用了MyClass类的自定义函数,而没有调用复制构造函数。产生这个现象的原因,在网络上有朋友提到“主要原因在于编译器的优化,当复制构造函数是public时,编译器就会根据这个特性来对代码进行优化。当程序运行时,编译器发现复制构造函数是public,则说明程序允许对象之间的复制,此时就会通过直接调用自定义构造函数来初始化对象,而不再调用复制构造函数,完成优化”。这位朋友还提到,如果将复制构造函数改为private,此时如下代码

    MyClass mc3 = “myclass”;

    编译时就会报错。

    但是,至少在VC++6.0及以上版本的编译器中,并不是这样的。在VC++6.0/VS2005/VS2008/VS2010/VS2015中进行测试,当将MyClass类的复制构造函数改为private后,上述代码编译时并不报错,而且都仅显示“调用了自定义构造函数”。这就说明,至少在VC++6.0/VS2005/VS2008/VS2010/VS2015的编译器当中,如下代码

    MyClass mc3 = “myclass”;

    并没有像《C++ Primer中文版第4版》中提到的那样,调用了两次构造函数,而是只调用了自定义的构造函数。可以说,在VC++6.0/VS2005/VS2008/VS2010/VS2015

    MyClass mc1(“myclass”);

    MyClass mc3 = “myclass”;

    是等价的。

    3 编译器优化

    VC++6.0/VS2005/VS2008/VS2010/VS2015中进行测试时,确实发现了在“2.2”中提到的编译器优化问题。对于如下代码

    MyClass mc4 = MyClass();

    VC++6.0中进行测试时,运行结果显示编译器先调用MyClass类默认构造函数,之后调用复制构造函数;而在VS2005/VS2008/VS2010/VS2015中则只显示编译器调用了默认构造函数。并且如果将复制构造函数设置为private,编译器会报错,如下所示:

     error C2248: ClassTest::ClassTest: 无法访问 private 成员(在“ClassTest”类中声明)

    这就说明,在VS2005/VS2008/VS2010/VS2015中,编译器进行了优化,当发现复制构造函数是public时,直接调用默认构造函数。而当复制构造函数是private时,就会报错。

    展开全文
  • copy函数 复制函数

    千次阅读 2019-03-26 16:20:49
    头文件 #include<algorithm> 将a[0]~a[2]复制到b[5]~b[7] 并且覆盖掉原来的数据 (主要用于容器之间) copy(a.begin(),a.begin()+3,b.begin()+4);

    头文件 

    #include<algorithm>

    将a[0]~a[2]复制到b[5]~b[7] 并且覆盖掉原来的数据 (主要用于容器之间)

    copy(a.begin(),a.begin()+3,b.begin()+4);

     

    展开全文
  • C++——构造函数、析构函数以及复制构造函数

    千次阅读 多人点赞 2021-03-09 16:28:49
    文章目录一、构造函数1.1 构造函数是什么?1.2 为什么要有构造函数?1.3 如何使用构造函数?1.4 构造函数的实现二、使用步骤 一、构造函数 在程序执行的过程中,当遇到与对声明语句时,程序会向操作系统申请一定的...

    一、构造函数

    在程序执行的过程中,当遇到与对声明语句时,程序会向操作系统申请一定的内存空间用于存放新建的对象。但是与普通变量相比,类的对象特别复杂,编译器不知如何产生代码去初始化对象,这便引出了构造函数。

    1.1 构造函数是什么?

    C++中,构造函数是一种特殊的成员函数,在每次创建一个类的时候编译器都会默认调用构造函数进行初始化。

    1.2 为什么要有构造函数?

    构造函数的作用就是在对象被创建的时候,利用特定的值构造对象,将对象初始化为一个特定的状态。

    1.3 如何使用构造函数?

    要学会如何使用构造函数,首先需要了解构造函数的一些特殊性质:构造函数的函数名与类名相同,而且没有返回值;构造函数通常被声明为公有函数。

    Notes:只要类中有了构造函数,编译器就会在创建新对象的地方自动插入对构造函数调用的代码。所以构造函数在对象被创建的时候将会被自动调用。

    下面分别介绍常见的几种构造函数:

    1. 默认构造函数:
    class Clock
    {
    public:
        Clock()   //编译器自动生成的隐含的默认构造函数;
        {
            
        }
        ....
    };
    

    默认构造函数调用时无须提供参数。如果类中没有写构造函数,那么编译器会自动生成一个隐含的默认构造参数,该构造函数的参数列表和函数体都为空,这个构造函数不做任何事情。

    Notes: 无参数的构造函数与全缺省的构造函数都称为默认构造函数。

    Q:既然默认构造函数不做任何事情,那么为什么还要生成这个构造函数?

    答:因为在建立对象时自动调用构造函数时C++必然要做的事情。上述例子中,默认构造函数什么都没有做,但是有些函数体为空的构造函数并非什么都不做,因为它还要负责基类的构造和成员对象的构造。

    1. 有参数的构造函数和无参数的构造函数
    class Clock
    {
    public:
        Clock(int NewH,int NewM,int NewS);  //有参数的构造函数
        Clock()   //无参数的构造函数
        {
            hour = 0;
            minute = 0;
            second = 0;
        }
        void SetTime(int NewH,int NewM,int NewS);
        void ShowTime();
    
    private:
        int hour,minute,second;
    };
    
    int main()
    {
        Clock(0,0,0); //调用有参数的构造函数
        Clock my_clock;  //调用无参数的构造函数
        return 0;
    }
    
    

    上述例子中出现了两种重载的构造函数的形式:有参数的和无参数的(即默认构造函数)

    1.4 构造函数的实现

    
    Clock::Clock(int NewH, int NewM, int NewS) 
    {
        hour = NewH;
        minute = NewM;
        second = NewS;
    }
    

    二、复制构造函数

    生成一个对象的副本有两种途径,第一种途径是建立一个新的对象,然后将原始对象的数据成员取出来,赋值给新对象。这样做显然太繁琐了,所以为了使得一个类具有自行复制本类对象的能力,复制构造函数被引出。

    2.1 什么是复制构造函数?

    复制构造函数是一种特殊的构造函数,其具有一般构造函数的所有特性,其形参是本类对象的引用。

    2.2 为什么要有复制构造函数?

    复制构造函数的作用是使得一个已经存在的对象(由复制构造函数的参数指定),去初始化一个同类的一个新对象。如果程序没有定义类的复制构造函数,系统就会在必要时自动生成一个隐藏的复制构造函数。这个隐藏的复制构造函数的功能是,把初始值对象的每个数据成员复制到新建立的对象中去。这样得到的对象和原本的对象具有相同的数据成员和属性。

    2.3 复制构造函数的功能

    在说明复制构造函数的功能之前,我们先看一下声明和实现复制构造函数的一般方法:

    class 类名
    {
    public:
        类名(形参); //构造函数
        类名(类名& 对象名); //复制构造函数
        ...
    };
    
    类名::类名(类名 &对象名) //复制构造函数的实现
    {
        //函数体
    }
    

    前面我们知道,普通的构造函数在对象被创建的时候调用,而复制构造函数在下面3种情况下均会被调用:

    例:

    class Point
    {
    public:
        Point(int x = 0,int y = 0)
        {
            _x = x;
            _y = y;
        }
        Point(Point& p); //复制构造函数
        int GetX()
        {
            return _x;
        }
        int GetY()
        {
            return _y;
        }
    
    private:
        int _x,_y;
    };
    
    1. 当用类的一个对象去初始化另一个对象时:
    int main()
    {
        Point a(1,2);
        Point b(a); //用对象a初始化对象b时,复制构造函数被调用
        Point c = a; //用对象a初始化对象c时,复制构造函数被调用
        return 0;
    }
    

    Notes:上面对b和c的初始化都能够调用复制构造函数,两种写法是等价的,执行的操作完全相同。

    1. 如果函数的形参是类的对象,调用函数时,进行形参和实参结合时:
    void Fun(Point p)
    {
        //函数体
    }
    
    int main()
    {
        Point a(1,2);
        Fun(a); //函数的形参为类的对象,当调用对象时,复制构造函数被调用.
        return  0;
    }
    

    Notes:只有把对象用值传递的时候,才会调用复制构造函数。如果传递的是引用,则不会调用复制构造函数。所以这也是传递引用会比传值的效率高的原因。

    1. 如果函数的返回值是类的对象,函数执行完成返回调用者时:
    Point Fun()
    {
        Point a(1,2);
        return a;  //函数Fun的返回值是类的对象,返回函数值的时候,调用复制构造函数
    }
    
    int main()
    {
        Point b;
        b = Fun();
        return 0;
    }
    

    Q:为什么在这种情况下,返回函数值的时候会调用复制构造函数?

    答:函数Fun()将a返回给了主函数,但是我们都知道a是Fun()的局部变量,当Fun()函数的生命周期结束的时候,a也就消亡了,不可能在返回主函数后继续生存。所以在这种情况下编译器会在主函数中创建一个无名的临时对象,该临时对象的生命周期仅仅在b = Fun()中。当执行语句return a时,实际上是调用复制构造函数将a的值复制到无名临时对象中。当函数Fun()运行结束时,对象a消失,但是临时对象会存在于b = Fun()中。当计算这个表达式后,临时对象也就完成了它的工作。

    三、析构函数

    我们刚讨论了当一个局部变量随着它的函数生命周期结束的时候,函数中的对象也会消失,那么在对象,要消失的时候(比如构造对象的时候,在函数中用malloc动态申请了空间)谁来做这些所谓的“善后”工作呢?这样我们就引出了析构函数。

    什么是析构函数?

    与构造函数一样,析构函数通常也是类的一个公有成员函数,它的名称是由类名前面加一个"~"构成,没有返回值。析构函数与构造函数不同的是,析构函数不接受任何参数!(参数可以是虚函数),如果我们不自行定义析构函数,则编译器同样会自动生成一个隐藏的析构函数,它的函数体为空。

    下面我们看一下析构函数的声明:

    class Clock
    {
    public:
        Clock(int NewH,int NewM,int NewS);  //有参数的构造函数
        Clock()   //无参数的构造函数
        {
            hour = 0;
            minute = 0;
            second = 0;
        }
        void SetTime(int NewH,int NewM,int NewS);
        void ShowTime();
        ~Clock(); //析构函数
    
    private:
        int hour,minute,second;
    };
    

    Notes:函数体为空的析构函数并不是什么都不做。

    Tips:
    类的构造顺序是按照语句的顺序进行构造
    类的析构函数调用完全按照构造函数调用的相反顺序进行调用
    1.全局对象先于局部对象进行构造
    2.静态对象先于普通对象进行构造

    展开全文
  • C++ 赋值构造函数 复制构造函数

    千次阅读 2018-08-25 15:29:11
    默认构造函数 编译器提供一个不接受任何参数,也不执行任何操作的构造函数,称之为默认构造函数 这是因为创造对象的时候总会调用默认构造函数 Klunk::Klunk() {} //定义 Klunk lunk; //声明 使用默认构造函数 ...

    这里写图片描述

    默认构造函数

    编译器提供一个不接受任何参数,也不执行任何操作的构造函数,称之为默认构造函数

    这是因为创造对象的时候总会调用默认构造函数

    Klunk::Klunk() {}   //定义
    Klunk lunk;         //声明  使用默认构造函数

    如果定义了构造函数,C++不会定义默认构造函数,如果希望创建对象时不显示地对他进行初始化,则必须显示的定义默认构造函数,这种默认的构造函数没有任何参数,但是可以用来设定特定的值,比如说:

    Klunk::Klunk() 
    {
        klunk_cnt = 0;
    }

    带参数的构造函数也可以是默认构造函数,只要所有的参数都有默认值
    Klunk::Klunk(int n = 0)
    {
    klunk_cnt = n;
    }

    但是注意,下面两种构造函数不能共同声明,会引起歧义

    Klunk::Klunk(int n = 0) {klunk_cnt = n;}
    Klunk::Klunk() {klunk_cnt = n;}
    
    Kulnk kar (10);  //这回选择只用第一种
    Kulnk bus;       //两种都可以,所以会报错

    复制构造函数

    // 对象的声明
    Stringbad sailor = sports

    上面这句话是常见的一种对象声明方式,这种对象方式使用了哪种构造函数呢?不是默认构造函数,也不是 Stringbad ::Stringbad (const char *)这种构造函数,而是等效于下面这句话

    StringBad sailor = StringBad (sports)

    因为sports的类型为StringBad ,所以说此时构造函数的原型如下

    StringBad (const StringBad  &)

    当使用一个对象初始化另一个对象的时候,编译器会自动生成构造函数,成为复制构造函数

    复制构造函数用于将一个对象复制到新创建的对象中。也就是说,它用于初始化过程中(包括按值传递参数),而不是常规的复制过程,累的复制构造函数原型:

    StringBad (const Class_name &) // 他接受一个指向类的对象的常量引用作为参数

    何时调用复制构造函数

    新建一个对象,并将其初始化为同类现有对象的时候,复制构造函数就会被调用,在很多情况下都可能发生,最常见的情况是将新对象显示的初始化为现有的对象

    StringBad ditto (motto)  //使用复制构造函数构造ditto
    StringBad metto = motto
    StringBad also = StringBad (motto)
    StringBad * pStringBad = new StringBad (motto)

    其中中间两种的声明可能会使用复制构造函数直接创建metto 和 also,也可能会生成一个临时对象,然后将临时兑现的内容赋值给metto 和also。最后一种是初始化一个匿名对象,并将新对象复制给指针。

    当函数按值传递对象或者函数返回对象时,都将会使用复制构造函数,每当程序生成了副本,编译器都将会使用复制构造函数

    注意: 由于使用按值传递的时候会调用复制构造函数,那么会浪费一定的时间和空间,所以应该经常使用引用传递参数,这样的话,可以节省调用构造函数的时间以及存储空间。

    默认的复制构造函数的功能
    默认的复制构造函数逐个复制非静态成员(成员复制也成为浅复制),复制的是成员的值

    StringBad sailor = sports;
    //与下面的函数等价
    StringBad sailor;
    sailor.str = sports.str;
    sailor.len = sports.len;

    浅复制构造函数带来的缺陷
    浅复制构造函数会让新的对象和以前的对象使用同一个地址,那么当调用析构函数的时候,析构了一次,但是会让两个对象都失去地址,然后GG思密达

    解决办法
    定义一个显示复制构造函数以解决问题
    所谓的显示复制构造函数,就是加了地址这一项。

    StringBad::StringBad (const StringBad & st)
    {
        num_strings++;
        len = st.len;
        str = new char [len + 1]
        std::strcpy (str, st.str);
    }

    警告:如果类中包含了使用new初始化的指针成员,应当定义一个复制构造函数,以复制指向的数据,而不是指针,这类被称为深度复制。复制的另一种形式是浅复制,只是复制指针值,浅复制仅仅浅浅的复制指针信息,而不会深入挖掘复制指针引用的结构


    赋值运算符

    运算符原型:

    Class_name & Class_name::operator=(const Class_name &);

    赋值运算符的功能以及何时使用它
    将已有的对象赋给另一个对象时,将使用重载的赋值运算符:

    StringBad headline1 ("Celery Stalks at Midnight");
    StringBad knot;
    knot = headline1;   // 使用复制构造函数创建一个临时对象然后通过赋值将临时对象复制到新的对象中。
    /*
        这样就是说初始化总是会调用复制构造函数创建一个临时的对象。
        然后通过赋值将临时对象的值复制到新对象中。
    */

    这个和上面的复制构造函数是有区别的
    复制构造函数:

    // 对象的声明
    Stringbad metoo= knot
    这里的metto是一个新创建的对象,被初始化knot的值,因此使用复制构造函数
    这里的knot是一个先使用默认构造函数创建的对象,然后使用knot对其进行赋值操作

    默认赋值运算符带来的问题
    使用默认的赋值运算符所产生的问题的原因和复制运算符产生的问题原因是一样的,都是同一块地址,析构就没有了。

    解决办法—-创建一个深复制函数
    实现与复制函数一样,但是也有一些小区别

    1. 由于目标对象可能引用了以前分配的数据,所以在使用之前使用delete[]进行释放
    2. 函数应当避免将对象赋值给自身,否则,给新对象重新赋值前,释放内存操作可能删除的对象
    3. 函数返回一个指向调用对象的引用。
    StringBad & StringBad::operator=(const StringBad & st)
    {
        if (&st == this)
            return *this;
        delete [] str;
        len = st.len;
        str = new char [len + 1];
        std::strcpy (str, st.str);
        return * this;
    }

    参考 《C++ Primer Plus》

    展开全文
  • 【C/C++】字符串函数复制函数

    万次阅读 2019-04-30 16:54:29
    C/C++字符串复制函数: C/C++字符串函数的头文件:string.h 复制函数主要有4个,如下: 1、char * strcpy(char* destination,const char * source); 2、char* strncpy(char* destination,const char* source,...
  • 写一个类的构造函数复制构造函数、析构函数、赋值函数 class CMyString { public:  CMyString(char* pData = NULL);  CMyString(const CMyString& str);  ~CMyString(void);  CMyString& ...
  • 一般来讲出现这个错误时,是因为复制构造函数的参数没有加const,加上就好了
  • 数组/容器初始化大小后,对象的构建过程。是调用默认构造函数还是调用复制构造函数
  • 如下一个类的定义,其定义了类的复制构造函数,和移动构造函数class B { public: B() :data(0) //默认构造函数 { cout ; } B(int i) :data(i) //带参数的构造函数 { cou
  • C++继承与构造函数复制控制

    千次阅读 2017-07-09 09:34:51
     构造函数复制控制成员不能继承,每个类定义自己的构造函数复制控制成员。像任何类一样,如果类不定义自己的默认构造函数复制控制成员,就将使用合成版本。   1:构造函数和继承  派生类的构造函
  • C++ Copy Constructor (拷贝构造函数,复制构造函数)

    万次阅读 多人点赞 2014-03-14 08:12:53
    Copy Constructor 是一个特殊的构造函数,一般只有一个参数,这个参数一般是用const修饰的,对自己类的一个引用(reference)。什么时候会用到Copy Constructor? 当我们定义一个对象时,它是由另外一个对象来初始化...
  • 1默认构造函数 当一个类没有任何构造函数时,编译器将会合成一个默认构造函数。 那么编译器合成的默认构造函数是做什么用的呢?是初始化类的成员变量吗? 事实上不是。编译器合成的默认构造函数只是满足编译器的...
  • C/C++字符串函数复制函数

    万次阅读 2011-09-07 18:04:55
    突然发现对字符串函数缺乏系统的了解,所以花了一点时间专门整理下,在此记录之,以方便自己及有需要的人使用。 C/C++字符串函数的...复制函数主要有4个,如下: 1、char * strcpy(char* destination,const char
  • 什么时候需要拷贝构造函数和赋值构造函数? 每个C++类只有一个析构函数,但可以有多个构造函数和多个赋值函数。其中构造函数包括默认构造函数(无参,或参数全有默认值),拷贝构造函数。在编程时,如果程序员不...
  • 这两个函数在基础性笔试中出镜率很高,所以有必要好好总结下:strcpy和memcpy都是标准C库函数,它们有下面的特点。 strcpy提供了字符串的复制。strcpy只用于字符串复制,并且它不仅复制源字符串内容之外,还会复制...
  • 复制构造函数总结

    千次阅读 2012-01-12 14:50:48
    1.用同一类型的对象来初始化另一对象需要调用复制构造函数 例1:class A { public: A(){} A(const A& a){cout;} }; int main() { A a, c; A b = a;//显式复制构造函数(1) c = a;//赋值函数(2) return 0; ...
  • 自定义函数复制字符串

    千次阅读 2017-10-16 15:14:59
    自定义函数复制字符串 自定义一个函数,然后将一串字符串输入到数组s1中
  • C++结构体提供了比C结构体更多的功能,如默认构造函数复制构造函数,运算符重载,这些功能使得结构体对象能够方便的传值。 比如,我定义一个简单的结构体,然后将其作为vector元素类型,要使用的话,就需要实现...
  • 初始化列表是用于构造函数参数的初始化,与其他函数不同,构造函数除了有名字,参数列表和函数体之外,还可以有初始化列表,初始化列表以冒号开头,后跟一系列以逗号分隔的初始化字段。 如: class myClock { ...
  • 没有可用的复制构造函数复制构造函数声明为“explicit” 使用方式: QList m_listCity; FourLevelAddressBase//自定义类 原因: FourLevelAddressBase类中没有拷贝构造函数(也叫做复制构造函数) 解决...
  • 近来做到几个关于对象作为函数形参,返回值时,构造函数复制构造函数,析构函数的调用顺序的问题,于是研究了一下,发现问题似乎还有些麻烦,现在在此分享下: 问题一: •对象参数的传递方式 •通过运行栈来...
  • 字符串复制函数strcpy()

    万次阅读 2019-05-26 14:58:31
    两个字符串变量不可以使用“=”进行直接赋值,只能通用strcpy()函数进行赋值。strcpy是 string copy的缩写,即“字符串复制”。他的原型是: #include<stdio.h> char *strcpy(char *dest, const char *src); ...
  • 什么是复制构造函数复制构造函数是一种特殊的构造函数,具有一般构造函数的所有特性 ,它的形参是本类的对象的引用,比如(类名 对象名)。它的作用是使用一个已经存在的对象(此对象由复制构造函数的参数决定...
  • C++派生类的构造函数复制控制

    千次阅读 2012-11-19 21:11:54
    派生类的构造函数复制控制成员不能继承,每个类定义自己的构造函数复制控制成员,像任何类一样,如果类没有定义自己的构造函数复制控制成员,编译器自动合成。 1.构造函数 派生类的构造函数先要初始化基类的...
  • C++中构造函数复制构造函数和赋值操作符三者分别何时被调用很容易让人犯迷糊,下面结合例子就这个问题讨论一下。 假设我们有如下代码段:#include #include using namespace std;class Foo {public: Foo() { ...
  • 派生类的构造函数复制控制

    千次阅读 2012-07-13 14:40:43
    因为派生类是从基类继承而来的,所以包含了基类的一些成员,所以在写派生类的构造函数复制控制函数时,必须考虑基类的影响。 先说构造函数,派生类的构造函数中,并不直接初始化基类的成员,而是调用基类的构造...
  • 默认构造函数和默认复制构造函数

    千次阅读 2011-09-14 21:18:57
    各种构造函数的区别  构造函数(包括拷贝构造函数)的基本功能:分配空间,初始化数据. 一.默认构造函数.  与用户自定义构造函数相比,默认构造函数有功能缺陷:只能分配空间,完成不了初始化数据的任务(类的数据成员...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,021,876
精华内容 408,750
关键字:

怎么把函数结果复制