精华内容
下载资源
问答
  • 类的赋值构造函数和复制构造函数

    千次阅读 2016-10-31 22:41:49
    C++的初学者经常会对复制构造函数一知半解,我曾经对复制构造函数和赋值函数就很是迷茫。闲来无事,整理一下,一个对象的赋值构造函数和赋值构造函数。整体的说一下,复制构造函数和赋值构造函数的相同点是: 赋值...

    C++的初学者经常会对复制构造函数一知半解,我曾经对复制构造函数和赋值函数就很是迷茫。闲来无事,整理一下,一个对象的复制构造函数和赋值构造函数。整体的说一下,复制构造函数和赋值构造函数的相同点是: 赋值运算符和复制构造函数都是用已存在的B对象来创建另一个对象A;
    最大的不同在于:赋值构造函数处理两个已有对象,即赋值前B应该是存在的;复制构造函数是生成一个全新的对象,即调用复制构造函数之前A不存在。

    - 类

    首先,介绍一下类:类是数据以及用于操纵该数据的方法(函数)的集合,是逻辑上相关函数与数据的封装。它是对所要处理问题的抽象描述,它把数据(事物的属性)和函数(事物的行为/操纵)封装为一个整体。
    类的定义格式如下:

    class 类名{
    private//私有数据和函数
    protect:
    //保护数据和函数
    public//公有数据和函数
    }

    C++中面向对象的思想是对对象的属性(成员变量)进行操作,应该通过对象的方法(成员函数)来进行,对象的方法是对象和外部的接口。
    这里顺便说一句成员函数的定义通常的格式是:

    范围值类型 类名::函数名(参数表)
    {
    //函数体
    }

    很多基础比较差的程序员,“::”符号不知道是什么意思(虽然知道也没什么用),只知道怎么用!运算符“::”成为作用域解析运算符,它指出该函数是属于哪一类的成员函数。当然也可以在类的定义中直接定义函数。所以有的时候也不用“::”符号.

    对象即类的实例。创建类的对象可以常用的两种方法:
    1、直接创建对象,比如CObject类的一个对象 CObject object;(注意这里的object是一个临时对象)
    2、采用动态创建类的对象的方法,当然遍历同样也可以动态创建。

    - 复制构造函数

    上面说到了类,也说到了对象的创建,那么同一个类的对象在内存中有完全相同的结构,如果作为一个整体进行复制是完全可行的。这个复制的过程只需要把数据成员复制过来即可,而函数成员是可以共用的,同一个类的任何对象都可以共用这个类的函数成员。
    在建立对象时可以用同一类的另一个对象来初始化该对象,这时所用的构造函数成为复制构造函数。像X::X(X&),这种形式,且只有一个参数——同类的对象,采用的是引用的方式。不能用X::X(X)这种形式的构造函数,如果把一个真实的类的对象作为参数传递到复制构造函数,会引起无穷的递归。那很多人有不解,平常我创建类的对象的时候也没有写复制构造函数呀,为什么也没有报错呢?原因是如果没有定义的话,那么编译器生成默认复制构造函数;如果定义了地自己的复制构造函数,则默认的复制构造函数就不存在了。(这一点与析构函数不同,即使自己定义了析构函数,默认的析构函数仍然存在)
    复制构造函数在以下3中情况下会被调用:

    1. 当用一个对象去初始化同类的另一个对象时。
    CObject o2(o1);
    //
    CObject o2=o1;
    1. 如果某函数有一个形参是类A的对象,那么该函数被调用时,类A的复制构造函数将被调用。
    void Fun(CObject object)
    {
        object.a=1;
    }
    CObject object;
    Fun(object);
    //CObject 的复制构造函数被调用,生成形参,在内存新建一个局部对象,并把实参复制到新的对象中。
    1. 如果函数的返回值是类CObject的对象,则函数返回时,CObject的复制构造函数被调用。理由也是建立一个临时对象,再返回调用者。
    CObject Fun()
    {
        CObject object;
        return object; //在此处调用了CObject(object)
    }
    int main()
    {
        CObject object; //此处是一个局部对象,也是一个临时对象
        object = Fun(); 
        return 0;
    }

    有人可能会问,为什么不直接用要返回的局部对象呢?因为局部对象在离开建立它的函数时就消亡了,不可能在返回调用函数后继续生存。所以编译系统会在调用函数的表达式中创建一个无名临时对象,该临时对象的生存周期只在函数调用处的表达式中。所谓返回对象,实际上就是调用复制构造函数把该对象的值复制到临时对象中。

    -赋值构造函数

    首先看一段代码:

    int main()
    {
        CObject theObjectOne;
        theObjectOne.Init(100);
    
        CObject theObjectTwo;
        theObjectTwo.Init(200);
    
        theObjectTwo = theObjectOne;
        //此操作是对象赋值操作,更深一步的操作时将被复制对象theObjectTwo对象原有的内容清除,并用theObjectOne对象里的内容填充。
        return 0;
    }

    “=”就是讲一个对象里的内容到另一个对象中去,这其中涉及到对象原有内容的丢弃和新内容的复制。由于对象内容包含指针,将造成不良的后果:指针的值被丢弃了(指针内容丢失了也就是说指针地址丢失了,但是改地址中所存储的内容没有丢失,但指针指向的内容并未释放。指针的值被复制了,但是指针所指内容并未复制,这就要出大事儿了)。所以如果类的对象中有指针的话,此处的“=”绝对不能是我们平常理解的简简单单的等于号,这个“=”必须重载,而这个“=”的重载函数就是我们要讨论的赋值构造函数。

    我们再来理解两个概念:值拷贝和位拷贝,位拷贝拷贝的是地址;值拷贝拷贝的是内容。理解了这两个概念我们再看一段代码:
    定义一个string类,但是不实现其他的成员函数

    Class String
    {
    public:
               String(const char *ch = NULL); //默认构造函数
               String(const String &str); //复制构造函数
               ~String();
               String &operator=(const String &str);//赋值构造函数
     privat:
                char *m_data;
    }
    
    int main()
    {
        String strA;
        strA.m_data=L"Windows";
        String strB;
        strB.m_data=L"Linux";
    
        strB.m_data = strA.m_data;
    }

    如果“=”未重写赋值构造函数的话,将strA赋给strB;则编译器会默认进行位拷贝,即strB.m_data = strA.m_data;
    则strA.m_data和strB.m_data都指向了同一块区域,虽然strA.m_data指向的内容会改变为“Linux”,但是会出现这样的问题:
    (1)strB.m_data原来指向的内存区域未释放,造成内存泄露。
    (2)strB.m_data和strA.m_data指向同一块区域,任何一方改变都会影响另一方。
    (3)当对象被析构时,strA.m_data被释放两次。

    如果“=”重写了复制构造函数后,strB.m_data = strA.m_data;进行的是值拷贝,会将strA.m_data的内容赋给strB.m_data,strB.m_data还是指向原来的内存区域,但是其内容改变。

    所以在我理解起来,赋值构造函数其实就是对“=”的重载。缺省的赋值构造函数采用的是“位拷贝”而非“值拷贝”的方式实现。如果类中含有指针变量,那么赋值构造函数如果不重载的话肯定会出错。理解到这里,我们再回过头看一下复制构造函数,其实也是一样的道理,缺省的复制构造函数采用的也是“位拷贝”的方式实现,所以如果类中含有指针变量的话我们也需要重写复制构造函数。
    总而言之一句话,什么把你弄的这么头疼来看这篇文章,归根到底就是——指针。

    最后附上一段不错的理解复制构造函数和赋值构造函数的代码:

    #include <iostream>
    #include <cstring>
    using namespace std;
    
    class String  
    {
        public:
            String(const char *str);
            String(const String &other);
            String & operator=(const String &other);
            ~String(void); 
        private:
            char *m_data;
    };
    
    String::String(const char *str)
    {
        cout << "自定义构造函数" << endl;
        if (str == NULL)
        {
            m_data = new char[1];
            *m_data = '\0';
        }
        else
        {
            int length = strlen(str);
            m_data = new char[length + 1];
            strcpy(m_data, str);
        }
    }
    
    String::String(const String &other)
    {
        cout << "自定义复制构造函数" << endl;
        int length = strlen(other.m_data);
        m_data = new char[length + 1];
        strcpy(m_data, other.m_data);
    }
    
    String & String::operator=(const String &other)
    {
        cout << "自定义赋值函数" << endl; 
    
        if (this == &other)
        {
            return *this;
        }
        else
        {
            delete [] m_data;
            int length = strlen(other.m_data);
            m_data = new char[length + 1];
            strcpy(m_data, other.m_data);
            return *this;
        }
    }
    
    String::~String(void)
    {
        cout << "自定义析构函数" << endl; 
        delete [] m_data;
    }
    int main()
    {
        cout << "a(\"abc\")" << endl;
        String a("abc");
    
        cout << "b(\"cde\")" << endl;
        String b("cde");
    
        cout << " d = a" << endl;
        String d = a;
    
        cout << "c(b)" << endl;
        String c(b);
    
        cout << "c = a" << endl;
        c = a;
    
        cout << endl;

    执行结果

    a(“abc”)
    执行自定义构造函数
    b(“ced”)
    执行自定义构造函数
    d=a
    执行自定义复制构造函数
    c(b)
    执行自定义复制构造函数
    c=a
    执行自定义赋值函数

    执行自定义析构函数
    执行自定义析构函数
    执行自定义析构函数
    执行自定义析构函数

    说明几点

    1. 赋值函数中,上来比较 this == &other 是很必要的,因为防止自复制,这是很危险的,因为下面有delete []m_data,如果提前把m_data给释放了,指针已成野指针,再赋值就错了

    2. 赋值函数中,接着要释放掉m_data,否则就没机会了(下边又有新指向了)

    3. 拷贝构造函数是对象被创建时调用,赋值函数只能被已经存在了的对象调用

      注意:String a(“hello”); String b(“world”); 调用自定义构造函数

           String c=a;调用拷贝构造函数,因为c一开始不存在,最好写成String c(a);
      
    展开全文
  • 正确答案: A 你的答案: A (正确) 构造函数不可以是私有的(private) 一个类中可以有多个构造函数 无论何时,只要类的对象被创建,就会执行构造函数 构造函数没有返回类型 ...

    正确答案: A 你的答案: A (正确)

    构造函数不可以是私有的(private)
    一个类中可以有多个构造函数
    无论何时,只要类的对象被创建,就会执行构造函数
    构造函数没有返回类型

    展开全文
  • 构造函数

    千次阅读 2021-01-28 16:49:43
    构造函数的作用以及写法:https://www.bilibili.com/video/BV1jJ41127dx/?spm_id_from=trigger_reload 构造函数的调用:https://www.bilibili.com/video/BV1jJ41127RB/?spm_id_from=trigger_reload ...//构造函数:类

    构造函数的作用以及写法:https://www.bilibili.com/video/BV1jJ41127dx/?spm_id_from=trigger_reload

    构造函数的调用:https://www.bilibili.com/video/BV1jJ41127RB/?spm_id_from=trigger_reload

    #include "stdafx.h"
    #include <stdlib.h>
    #include <string.h>
    
    //构造与析构
    //构造函数:类定义了一个对象,可以在定义的时候对其附一个初值;
    //1.用于对象的初始化
    //2.写法:
    //    1)函数名必须是类名;2)不写函数的返回值;3)可以有参数>=0;
    //3.构造函数允许函数的重载
    //4.如果类中一个构造函数都没有,编译器会提供一个默认构造函数(无参数的构造,可能会被优化)
    /新添加标准:
    //1).explicit关键字:只支持显示调用构造函数,不允许隐士转换
    //2)=default 类中:CStudent() = delete;表示删除CStudent构造函数
    //3)=delete       CStudent() = default ;表示显示的指出使用默认的构造函数
    
    //描述班级学生
    
    class CStudent {
    public:
    //构造函数
    //没有参数的构造函数
        CStudent (){
    // strcpy_s(m_szName,pszName);
    printf("CStudnet()\r\n");
    }
    //一个参数的构造函数
        CStudent (char* pszName){   
    // strcpy_s(m_szName,pszName);
    printf("CStudnet()\r\n");
    }
    //两个参数的构造函数
        CStudent (int nStuID,char* pszName){
    // strcpy_s(m_szName,pszName);
    printf("CStudnet()\r\n");
    }
        void SetName(char* pszName){
            strcpy_s(m_szName,pszName); //外部可能会引起缓冲区溢出 pszName=m_szName;
    }
    
    private:
        int m_nStuID;
        char m_szName[255];
    };
    
    int main()
    {
    
    CStudnet  stu = "张三"; //正确:CStudnet stu("张三") 或则CStudnet  stu=CStudnet("张三")
    //CStudnet stu;
    //stu.SetName("张三");
    
    CStudnet stu2;    //编译不过
    stu.SetName("李四");
    
    };

     

    展开全文
  • 复制构造函数与拷贝构造函数

    千次阅读 2014-09-16 11:39:03
    对于我来说,在写代码的时候能用得上复制构造函数的机会并不多,不过这并不说明复制构造函数没什么用,其实复制构造函数能解决一些我们常常会忽略的问题。  为了说明复制构造函数作用,我先说
    总结:
    都是传对象用的
    复制构造函数:内存类是传值
    拷贝构造哈虎:内存中是引用


    也许很多C++的初学者都知道什么是构造函数,但是对复制构造函数(copy constructor)却还很陌生。对于我来说,在写代码的时候能用得上复制构造函数的机会并不多,不过这并不说明复制构造函数没什么用,其实复制构造函数能解决一些我们常常会忽略的问题。
           为了说明复制构造函数作用,我先说说我们在编程时会遇到的一些问题。对于C++中的函数,我们应该很熟悉了,因为平常经常使用;对于类的对象,我们也很熟悉,因为我们也经常写各种各样的类,使用各种各样的对象;对于指针的操作,我们也不陌生吧?嗯,如果你还不了解上面三个概念的话,我想这篇文章不太适合你,不过看看也无碍^_^。我们经常使用函数,传递过各种各样的参数给函数,不过把对象(注意是对象,而不是对象的指针或对象的引用)当作参数传给函数的情况我们应该比较少遇见吧,而且这个对象的构造函数还涉及到一些内存分配的操作。嗯,这样会有什么问题呢?
           把参数传递给函数有三种方法,一种是值传递,一种是传地址,还有一种是传引用。前者与后两者不同的地方在于:当使用值传递的时候,会在函数里面生成传递参数的一个副本,这个副本的内容是按位从原始参数那里复制过来的,两者的内容是相同的。当原始参数是一个类的对象时,它也会产生一个对象的副本,不过在这里要注意。一般对象产生时都会触发构造函数的执行,但是在产生对象的副本时却不会这样,这时执行的是对象的复制构造函数。为什么会这样?嗯,一般的构造函数都是会完成一些成员属性初始化的工作,在对象传递给某一函数之前,对象的一些属性可能已经被改变了,如果在产生对象副本的时候再执行对象的构造函数,那么这个对象的属性又再恢复到原始状态,这并不是我们想要的。所以在产生对象副本的时候,构造函数不会被执行,被执行的是一个默认的构造函数。当函数执行完毕要返回的时候,对象副本会执行析构函数,如果你的析构函数是空的话,就不会发生什么问题,但一般的析构函数都是要完成一些清理工作,如释放指针所指向的内存空间。这时候问题就可能要出现了。假如你在构造函数里面为一个指针变量分配了内存,在析构函数里面释放分配给这个指针所指向的内存空间,那么在把对象传递给函数至函数结束返回这一过程会发生什么事情呢?首先有一个对象的副本产生了,这个副本也有一个指针,它和原始对象的指针是指向同块内存空间的。函数返回时,对象的析构函数被执行了,即释放了对象副本里面指针所指向的内存空间,但是这个内存空间对原始对象还是有用的啊,就程序本身而言,这是一个严重的错误。然而错误还没结束,当原始对象也被销毁的时候,析构函数再次执行,对同一块系统动态分配的内存空间释放两次是一个未知的操作,将会产生严重的错误。
           上面说的就是我们会遇到的问题。解决问题的方法是什么呢?首先我们想到的是不要以传值的方式来传递参数,我们可以用传地址或传引用。没错,这样的确可以避免上面的情况,而且在允许的情况下,传地址或传引用是最好的方法,但这并不适合所有的情况,有时我们不希望在函数里面的一些操作会影响到函数外部的变量。那要怎么办呢?可以利用复制构造函数来解决这一问题。复制构造函数就是在产生对象副本的时候执行的,我们可以定义自己的复制构造函数。在复制构造函数里面我们申请一个新的内存空间来保存构造函数里面的那个指针所指向的内容。这样在执行对象副本的析构函数时,释放的就是复制构造函数里面所申请的那个内存空间。
           除了将对象传递给函数时会存在以上问题,还有一种情况也会存在以上问题,就是当函数返回对象时,会产生一个临时对象,这个临时对象和对象的副本性质差不多。
    拷贝构造函数,经常被称作X(X&),是一种特殊的构造函数,他由编译器调用来完成一些基于同一类的其他对象的构件及初始化。它的唯一的一个参数(对象的引用)是不可变的(因为是const型的)。这个函数经常用在函数调用期间于用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话,它将用常量方式调用,另外,也可以用非常量方式调用。 
    在C++中,下面三种对象需要拷贝的情况。因此,拷贝构造函数将会被调用。 
    1). 一个对象以值传递的方式传入函数体 
    2). 一个对象以值传递的方式从函数返回 
    3). 一个对象需要通过另外一个对象进行初始化 
    以上的情况需要拷贝构造函数的调用。如果在前两种情况不使用拷贝构造函数的时候,就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说,初始化和赋值的不同含义是构造函数调用的原因。事实上,拷贝构造函数是由普通构造函数和赋值操作赋共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。 
    拷贝构造函数不可以改变它所引用的对象,其原因如下:当一个对象以传递值的方式传一个函数的时候,拷贝构造函数自动的被调用来生成函数中的对象。如果一个对象是被传入自己的拷贝构造函数,它的拷贝构造函数将会被调用来拷贝这个对象这样复制才可以传入它自己的拷贝构造函数,这会导致无限循环。 
    除了当对象传入函数的时候被隐式调用以外,拷贝构造函数在对象被函数返回的时候也同样的被调用。换句话说,你从函数返回得到的只是对象的一份拷贝。但是同样的,拷贝构造函数被正确的调用了,你不必担心。 
    如果在类中没有显式的声明一个拷贝构造函数,那么,编译器会私下里为你制定一个函数来进行对象之间的位拷贝(bitwise copy)。这个隐含的拷贝构造函数简单的关联了所有的类成员。许多作者都会提及这个默认的拷贝构造函数。注意到这个隐式的拷贝构造函数和显式声明的拷贝构造函数的不同在于对于成员的关联方式。显式声明的拷贝构造函数关联的只是被实例化的类成员的缺省构造函数除非另外一个构造函数在类初始化或者在构造列表的时候被调用。 
    拷贝构造函数是程序更加有效率,因为它不用再构造一个对象的时候改变构造函数的参数列表。设计拷贝构造函数是一个良好的风格,即使是编译系统提供的帮助你申请内存默认拷贝构造函数。事实上,默认拷贝构造函数可以应付许多情况。
    附另外一篇关于复制构造函数的文章:

    对一个简单变量的初始化方法是用一个常量或变量初始化另一个变量,例如:
      int m = 80;
      int n = m;
      我们已经会用构造函数初始化对象,那么我们能不能象简单变量的初始化一样,直接用一个对象来初始化另一个对象呢?答案是肯定的。我们以前面定义的Point类为例:
      Point pt1(15, 25);
      Point pt2 = pt1;
    后一个语句也可以写成:
      Point pt2( pt1);
    它是用pt1初始化pt2,此时,pt2各个成员的值与pt1各个成员的值相同,也就是说,pt1各个成员的值被复制到pt2相应的成员当中。在这个初始化过程当中,实际上调用了一个复制构造函数。当我们没有显式定义一个复制构造函数时,编译器会隐式定义一个缺省的复制构造函数,它是一个内联的、公有的成员,它具有下面的原型形式:
      Point:: Point (const Point &);
    可见,复制构造函数与构造函数的不同之处在于形参,前者的形参是Point对象的引用,其功能是将一个对象的每一个成员复制到另一个对象对应的成员当中。
      虽然没有必要,我们也可以为Point类显式定义一个复制构造函数:
      Point:: Point (const Point &pt)
      {
       xVal=pt. xVal;
       yVal=pt. yVal;
      } 
      如果一个类中有指针成员,使用缺省的复制构造函数初始化对象就会出现问题。为了说明存在的问题,我们假定对象A与对象B是相同的类,有一个指针成员,指向对象C。当用对象B初始化对象A时,缺省的复制构造函数将B中每一个成员的值复制到A的对应的成员当中,但并没有复制对象C。也就是说,对象A和对象B中的指针成员均指向对象C,实际上,我们希望对象C也被复制,得到C的对象副本D。否则,当对象A和B销毁时,会对对象C的内存区重复释放,而导致错误。为了使对象C也被复制,就必须显式定义复制构造函数。下面我们以string类为例说明,如何定义这个复制构造函数。

    例10-11
      class String
    {
     public:
      String(); //构造函数
      String(const String &s); //复制构造函数
      ~String(); //析构函数

      // 接口函数
      void set(char const *data);
      char const *get(void);

     private:
      char *str; //数据成员ptr指向分配的字符串
    };

    String ::String(const String &s)
    {
     str = new char[strlen(s.str) + 1];
     strcpy(str, s.str);
    }

    我们也常用无名对象初始化另一个对象,例如:
      Point pt = Point(10, 20);
      类名直接调用构造函数就生成了一个无名对象,上式用左边的无名对象初始化右边的pt对象。
      构造函数被调用通常发生在以下三种情况,第一种情况就是我们上面看到的:用一个对象初始化另一个对象时;第二种情况是当对象作函数参数,实参传给形参时;第三种情况是程序运行过程中创建其它临时对象时。下面我们再举一个例子,就第二种情况和第三种情况进行说明:
      Point foo(Point pt) 
      { 
       … 
       return pt;
      }
      void main()
      {
       Point pt1 = Point(10, 20);
       Point pt2;
       …
       pt2=foo(pt);
       …
      }
      在main函数中调用foo函数时,实参pt传给形参pt,将实参pt复制给形参pt,要调用复制构造函数,当函数foo返回时,要创建一个pt的临时对象,此时也要调用复制构造函数。

    缺省的复制构造函数
      在类的定义中,如果没有显式定义复制构造函数,C++编译器会自动地定义一个缺省的复制构造函数。下面是使用复制构造函数的一个例子:

    例10-12
      #include <iostream.h>
    #include <string.h>
    class withCC
    {
     public:
     withCC(){}
     withCC(const withCC&)
     {
      cout<<"withCC(withCC&)"<<endl;
     }
    };

    class woCC
    {
     enum{bsz = 100};
     char buf[bsz];
    public:
     woCC(const char* msg = 0)
     {
      memset(buf, 0, bsz);
      if(msg) strncpy(buf, msg, bsz);
     }
     void print(const char* msg = 0)const
     {
      if(msg) cout<<msg<<":";
      cout<<buf<<endl;
     }
    };

    class composite
    {
     withCC WITHCC;
     woCC WOCC;
    public:
     composite() : WOCC("composite()"){}
     void print(const char* msg = 0)
     {
      WOCC.print(msg);
     }
    };

    void main()
    {
     composite c;
     c.print("contents of c");
     cout<<"calling composite copy-constructor"<<endl;
     composite c2 = c;
     c2.print("contents of c2");
    }

      类withCC有一个复制构造函数,类woCC和类composite都没有显式定义复制构造函数。如果在类中没有显式定义复制构造函数,则编译器将自动地创建一个缺省的构造函数。不过在这种情况下,这个构造函数什么也不作。
      类composite既含有withCC类的成员对象又含有woCC类的成员对象,它使用无参的构造函数创建withCC类的对象WITHCC(注意内嵌的对象WOCC的初始化方法)。
      在main()函数中,语句:
      composite c2 = c;
    通过对象C初始化对象c2,缺省的复制构造函数被调用。
      最好的方法是创建自己的复制构造函数而不要指望编译器创建,这样就能保证程序在我们自己的控制之下。


    原文地址:http://blog.csdn.net/feiyond/article/details/1807068

    ——————————————————chenchen————————————————————-
    展开全文
  • 默认构造函数和拷贝构造函数

    千次阅读 2014-10-08 09:51:47
    如果类包含内置或复合类型的成员,则该类就不应该依赖于合成的默认构造函数,它应该定义自己的构造函数来初始化这些成员。
  • 一、分析  一般来说,我们经常使用的枚举项只有一个属性,即排序号,其默认值是从0、...比如,可以通过枚举构造函数声明业务值,定义可选项,添加属性,看如下代码:  enum Role{ Admin("管理员",new Lifetim
  • Java构造函数

    万次阅读 2019-04-26 20:08:04
    构造函数是面向对象中的一员,构造函数可以叫做构造器,它的函数名与类名相同,不用定义返回值类型,也-没有具体的返回值。构造函数是在构建创造时对象时调用函数,作用是可以给对象进行初始化,创建对象都必须要...
  • 答:  只有一种,默认构造函数。(不带参数的构造函数) 答: ... 1....如果用户没有定义任何构造函数,则编译器会默认提供这个构造函数。  2.带有默认值得构造函数。比如Example(int a = 23);
  • C++中一般创建对象,拷贝或赋值的方式有构造函数,拷贝构造函数,赋值函数这三种方法。下面就详细比较下三者之间的区别以及它们的具体实现 1.构造函数 构造函数是一种特殊的类成员函数,是当创建一个类的对象时,...
  • 构造函数与普通函数的区别

    千次阅读 2019-05-26 16:58:44
    构造函数构造函数的作用: 给对应的对象进行初始化。 构造函数的定义的格式: 修饰符 函数名(形式参数){ 函数体... } 构造函数要注意的细节: 1. 构造函数 是没有返回值类型的。 2. 构造函数的函数名...
  • 构造函数与构造代码块

    千次阅读 2018-01-24 23:00:35
    构造函数 1.构造函数的作用:给对应的对象进行初始化。 2.构造函数的定义格式: 修饰符 函数名(形式参数){  函数体; } 3.构造函数要注意的细节: (1)构造函数是没有返回值类型的。 (2)构造函数的函数名...
  • 构造函数和析构函数的调用顺序

    千次阅读 2019-09-03 15:47:29
    目录构造函数和析构函数构造函数复制构造函数析构函数构造函数与析构函数的调用顺序单继承多继承 构造函数和析构函数 构造函数 构造函数是特殊的成员函数,与类同名,没有返回类型,而且允许重载。如果没有为类显式...
  • 3-1 Point类的构造函数 Time Limit: 1000MS Memory limit: 65536K 题目描述 通过本题目的练习可以掌握类的构造函数的定义; 设计一个点类Point,私有数据成员有x、y;公有成员函数有:无参数的构造函数Point()...
  • 关于使用C++11中委托构造函数

    千次阅读 多人点赞 2017-06-29 11:18:01
    今天在读《C++Primer》时读到委托构造函数一节,书中关于委托构造函数是这样描述的: 一个委托构造函数使用它所属的类的其他构造函数执行自己的初始化过程,或者说它把自己的一些(或者全部)职责委托给了其他构造...
  • 复制构造函数(拷贝构造函数

    万次阅读 多人点赞 2007-09-29 21:56:00
    也许很多C++的初学者都知道什么是构造函数,但是对复制构造函数(copy constructor)却还很陌生。对于我来说,在写代码的时候能用得上复制构造函数的机会并不多,不过这并不说明复制构造函数没什么用,其实复制构造...
  • Java构造函数 为什么需要无参构造函数  分享| 2013-05-08 16:20匿名 | 浏览 3298 次  java编程语言函数 class cust { int a; cust(){} cust(int a) { this.a=a; } } class test { cust A=...
  • c++学习笔记八:构造函数和析构函数详解

    千次阅读 多人点赞 2020-11-08 22:21:02
    一、构造函数和析构函数基本概念 对象的初始化和清理也是两个非常重要的安全问题 ​一个对象或者变量没有初始状态,对其使用后果是未知 ​同样的使用完一个对象或变量,没有及时清理,也会造成一定的安全问题 c++...
  • 拷贝构造函数

    千次阅读 2013-03-22 16:24:50
    拷贝构造函数作用及用途?什么时候需要自定义拷贝构造函数? 也许很多C++的初学者都知道什么是构造函数,但是对复制构造函数(copy constructor)却还很陌生。对于我来说,在写代码的时候能用得上复制构造函数...
  • 问题描述: 已知String 类定义如下: class String { public: String(const ... // 通用构造函数 String(const String &another); // 拷贝构造函数 ~ String(); // 析构函数 String & operater =(const Strin
  • C++构造函数语义——默认构造函数

    千次阅读 2012-09-05 22:02:33
     《The C++ ARM》告诉我们:“默认构造函数会在需要的时候自动生成(被编译器)。”然后“在需要的时候”是一个很抽象的概念,本文主要描述的问题也正是这些需要的情况。  我们看看下面的代码片段: class Foo {...
  • list构造函数

    千次阅读 2019-07-04 16:59:45
    功能描述: 创建list容器 函数原型: list<T> lst; //list采用模板类实现对象的默认构造形式: list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。 list(n,elem); ...
  • C++ 拷贝构造函数

    千次阅读 2014-05-24 16:27:10
    拷贝构造函数,是一种特殊的构造函数,它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的形参必须是引用,但并不限制为const,一般普遍的会加上const限制。此函数经常用在函数调用时用户定义...
  • Qt构造函数的初始化问题

    千次阅读 2020-08-10 15:32:06
    QT中用父类构造函数初始化子类的成员变量 Qt ------ 初始化构造函数参数,parent C++ 构造函数和析构函数是否可以继承? 描述 在Qt新建继承Qt类的类后,经常会在构造函数看到parent的参数的初始化。如: ...
  • 关于组合类中构造函数调用的分析

    千次阅读 2020-04-05 10:18:57
    关于组合类中构造函数调用的分析 组合类相关的概念 一种包含与被包含的关系。 例如,用一个类来描述计算机系统.首先可以把它分解为硬件和软件 硬件包含中央处理单元(CPU)存储器、输入设备和输出设备,软件可以包括系统...
  • 默认构造函数详解

    万次阅读 2018-05-10 11:20:26
    错误认识1:若程序员没有自己定义无参数的构造函数,那么编译器会自动生成默认构造函数,来进行对成员函数的初始化。错误认识2:编译器合成出来的default constructor会明确设定'“class内每一个data member的默认值...
  • 当调用派生类C的构造函数动态创建派生类对象时,只调用一次虚基类A的构造函数,\ 而派生类C的直接基类B1,B2(同时也是A的派生类)对虚基类A的构造函数的调用将被忽略。 例子: #include using namespace std; ...
  • 构造函数详解

    2018-09-16 21:07:01
    (一)、构造函数的原理  记住当使用new的时候,到底发生了什么事情,在使用new操作符来调用一个构造函数的时候,发生了什么呢?其实很简单,就发生了四件事: var obj ={}; //创建对象的一种方式 obj.__proto_...
  • 构造函数 —— 学生信息类

    千次阅读 2020-10-26 12:41:17
    构造函数 —— 学生信息类 一、任务描述 本关任务:设计一个带有构造函数和析构函数的学生类。 二、相关知识 构造函数、析构函数与赋值函数是每个类最基本的函数。他们太普通以致让人容易麻痹大意,其实这些貌似简单...
  • 复制构造函数

    千次阅读 2012-02-21 21:45:47
    也许很多C++的初学者都知道什么是构造函数,但是对复制构造函数(copy constructor)却还很陌生。对于我来说,在写代码的时候能用得上复制构造函数的机会并不多,不过这并不说明复制构造函数没什么用,其实复制构造...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 450,633
精华内容 180,253
关键字:

关于构造函数的描述