精华内容
下载资源
问答
  • 前言,在c++面试过程中,最能考察的基础知识的莫过于写一个具有的必要函数。这个面试题是一些面试官非常喜欢的,不但要写出来,还有很多知识点可以考察。 定义一个类如下 class String { public: ...

    前言,在c++面试过程中,最能考察类的基础知识的莫过于写一个具有类的必要函数的类。这个面试题是一些面试官非常喜欢的,不但要写出来,还有很多知识点可以考察。

    定义一个类如下

    class String {
        public:
        String(const char *str=NULL);
        ~String();
        String(const String &others);
        String &operator=(const String &others);
        void show();
        private:
        char *data;
    };

    方法实现如下:

    String::String(const char *str) {
        if (NULL == str) {
            data = new char[1];
            data[0] = '\0';
        }else {
            data = new char[strlen(str) + 1];
            strcpy(data, str);
        }
    
    }
    
    String ::String(const String &others) {
        if (&others != this) {
            data = new char[strlen(others.data) + 1];
            strcpy(data, others.data);
        }
    }
    
    String &String::operator=(const String &others) {
        if (&others == this)
            return *this;
        delete []data;
        data = new char[strlen(others.data) + 1];
        strcpy(data, others.data);
        return *this;
    }
    
    void String::show() {
        printf("data: %s\n", data);
    }
    
    
    String ::~String() {
        delete []data;
    }

    写到这里,基础的知识点用到了不少,但是如果面试继续问如下的问题呢

    1 写一个静态的成员变量

    2 写一个const类型的成员变量

    3 写一个引用类型的成员变量

    4 String a; String b = a (调用的是哪个函数?)

    还能不能继续写下去呢?

    1 静态成员函数,可以在类内部声明 比如 static  int  count; 

    2 const成员变量,在类内部声明, 但是必须在构造函数采用初始化列表进行初始化,比如 const int max;

    3 引用成员, int &ref, int aa; 初始化如下,别忘了,所有构造函数都必须初始化,包括拷贝构造函数

       

    String::String(const char *str):<span style="color:#ff0000;">max(100),ref(aa)</span>{
        if (NULL == str) {
            data = new char[1];
            data[0] = '\0';
        }else {
            data = new char[strlen(str) + 1];
            strcpy(data, str);
        }
    
    }

    4 String b = a , 调用的是拷贝构造函数, 而不是赋值函数,此处经常有人答错。

    5 String  a, b ; a = b 此时调用的才是赋值函数。

    有些时场合初始化列表是不可或缺的,以下几种情况时必须使用初始化列表

         1 常量成员,因为常量只能初始化不能赋值,所以必须放在初始化列表里面

        2 引用类型,引用必须在定义的时候初始化,并且不能重新赋值,所以也要写在初始化列表里

        3 没有默认构造函数的类类型,因为使用初始化列表可以不必调用默认构造函数来初始化,而是直接调用拷贝构造函数初始化。

    最后特别说明的一点是, 初始化列表的赋值顺序是按照成员变量在类中的定义的顺序,而不是初始化列表的顺序

    class Test {
        int i;
        int j;
        Test(int x) :j(x),i(j) {}
    };

    这里的i是未知的,因为声明时i在j前,所以初始化列表中先给i赋值,但是此时j的值还未知,所以,最好按照成员定义的顺序进行初始化。


    展开全文
  • C++中的——构造函数

    千次阅读 2018-08-29 13:57:31
    每个都分别定义了它的对象被初始化的方式,通过一个几个特殊的成员函数来控制其对象的初始化过程,这些函数叫构造函数构造函数的任务是初始化对象的数据成员,无论何时只要的对象被创建,就会执行构造...

    一、什么是构造函数

    每个类都分别定义了它的对象被初始化的方式,类通过一个或几个特殊的成员函数来控制其对象的初始化过程,这些函数叫构造函数。构造函数的任务是初始化类对象的数据成员,无论何时只要类的对象被创建,就会执行构造函数。


    二、构造函数的定义

    class 类名

    {

       访问说明符:

       类名(形参列表):初始值列表{函数体定义}

    };

    ————————————————————————————————————————————————

    1、构造函数的名字和类名相同、无返回类型有一个(可能为空的)参数列表和一个(可能为空的)函数体。

    2、类可以包含多个构造函数,和其他重载函数差不多,不同的构造函数之间必须在参数数量或参数类型上有所区别。

    3、不同于其他成员函数,构造函数不能被声明成const的。当我们创建类的一个const对象时,直到构造函数完成初始化过程,对象才能真正取得其“常亮”属性。因此,构造函数在const对象的构造过程中可以向其写值。

    4、与其他成员函数相同的是,构造函数在类外定义时也需要明确指出是哪个类。

    5、通常情况下,我们将构造函数声明为public的,可以供外部调用。然而有时候我们会将构造函数声明为private或protected的:(1)如果类的作者不希望用户直接构造一个类对象,着只是希望用户构造这个类的子类,那么就可以将构造函数声明为protected,而将该类的子类声明为public。(2)如果将构造函数声明为private,那只有这个类的成员函数才能构造这个类的对象。

    默认构造函数

    6、默认构造函数:默认构造函数没有参数,即在实例化对象时不需要给定初始值,这时所调用的构造函数为默认构造函数。默认构造函数的初始化规则:(1)如果存在类内初始值,则用它来初始化成员。(2)默认初始化。

    7、合成的默认构造函数:当类没有声明任何构造函数时,编译器便会自动地生成默认构造函数。这个由编译器自动创建的构造函数叫做合成的默认构造函数。

    8、如果类包含有内置类型或复合类型的成员,则只有当这些成员全部被赋予了类内的初始值时,这个类才适合于使用合成的默认构造函数。因为如果对象定义在块中,则该对象的成员初始值将是不可预测的。

    9、有些时候编译器不能为某些类合成默认的构造函数。例如,如果类中包含一个其他类类型的成员且这个成员的类型没有默认构造函数,那么编译器将无法初始化该成员。对于这样的类来说,我们必须自定义默认构造函数,否则该类将没有可用的默认构造函数。当然还有一些其他的情况也会导致编译器无法生成一个正确的默认构造函数。

    10、如果类内已经定义了其他的构造函数,那么强烈建议定义一个默认构造函数。我们定义默认构造函数的目的是因为我们即需要在定义类类型的对象时给予初始值的其他形式的构造函数,也需要在定义类类型的对象时不给予初始化参数而根据类内初始值初始化或默认初始化的默认构造函数。我们希望这个函数的作用完全等同于之前使用的合成默认构造函数。

    11、在C++11新标准中,如果我们需要默认的行为,那么可以通过在参数列表后写上“=default”(不含引号)来要求编译器生成构造函数。其中,“=default”即可以和声明一起出现在类的内部,也可以作为定义出现在类的外部。在不支持C++11的情况下,可以用一个空参数列表空初始值列表(见下文)函数体内不对成员进行赋值操作的构造函数来代替(典型的:类名(){})。

    构造函数初始值列表

    构造函数初始值列表:类名(形参列表):数据成员1(初始值),数据成员2(初始值)...{函数体}

    上面蓝色部分即为构造函数初始值列表,他负责为新创建的对象的一个或几个数据成员赋初始值。

    ————————————————————————————————————————————————

    12、构造函数初始值是成员名字的一个列表,每个名字后紧跟括号括起来的(或者在花括号内)成员初始值。不同成员的初始化通过逗号分隔开来。

    13、构造函数初始值列表只说明用于初始化成员的值,而不限定初始化的具体执行循序。实质上,成员的初始化顺序与它们在类定义中的出现顺序一致。然而如果一个成员是用另一个成员初始化的,那么这两个成员的初始化顺序就很重要了。有的编译器会当构造函数的初始值列表中的数据成员顺序与这些成员声明的顺序不符时生成一条警告信息。最好令构造函数初始值的顺序与成员声明的顺序保持一致,并且可能的话,最好用构造函数的参数作为成员的初始值,而避免使用同一个对象的其他成员,这样就不必考虑成员的初始化顺序了。

    14、如果没有在构造函数的初始值列表中显式的初始化成员,则该成员将在构造函数体之前执行类内初始值初始化或默认初始化。这一点也就解释了在不支持C++11的情况下如何生成一个执行默认操作的默认构造函数(见第11点)。

    15、一旦构造函数体开始执行,也就意味着初始化结束了。可以在构造函数体内部重新为成员赋值。有时我们可以忽略数据成员初始化和赋值之间的差异,但并非总能这样。例如,如果成员是const或者引用或属于某种类类型且该类没有定义默认构造函数时,必须将这个成员初始化。

    默认实参构造函数

    16、构造函数也可以具有默认的实参,如果一个构造函数为所有参数都提供了默认实参,则它实际上也定义了默认构造函数。

    三、委托构造函数

    class 类名

    {

    public:

       类名(int a,string b,vector<string> c):aa(a),bb(b){ cc=c; }//构造函数

       类名(形参列表):类名(0," "){}//委托构造函数

       类名(形参列表):类名(5,"hellol"){}//委托构造函数

    private:

       int aa;

       string bb;

       vector<string> cc;

    };

    ————————————————————————————————————————————————

    17、C++11新标准扩展了构造函数初始值的功能,我们可以定义委托构造函数。一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程,或者说它把它自己的一些(或者全部)职责委托给了其他构造函数。

    18、委托构造函数也有一个成员初始值列表(相当于对构造函数的调用)和一个函数体。在委托构造函数内,成员初始值列表只有一个唯一的入口,就是类名本身。和其他成员初始值一样,类名后面紧跟圆括号括起来的参数列表,参数列表必须与另一个构造函数匹配。

    19、当一个构造函数委托给另一个构造函数时,受委托的构造函数的初始值列表和函数体被依次执行,然后控制权才会交给委托者的函数体。

    20、委托可以多级传递,即A可以委托给B,B又可以委托给C。

    四、隐式的类类型转换

    21、如果构造函数只接受一个实参,则它便具有了转换为此类类型的隐式转换机制。把这种构造函数称为转换构造函数。具体表现在:在成员函数的参数为类类型时,可以为其传一个数据成员值,该值会自动转换成一个类类型的临时对象作为实参。

    22、需要注意以下几点;(1)转换前传递的实参必须具有对应的转换构造函数。(2)编译器只会自动的执行一步类型转换。(例如,需要一个string类型作为形参的转换构造函数,我们不能用一个字符串字面量作为实参去掉用需要该类类型作为形参的成员函数,因为这时需要两部转换)(3)临时的中间变量都是const,所有没有const的引用会失败。所以如果成员函数的形参为该类类型的引用,则必须将其定义为const类型。

    #include <iostream>
    using namespace std;
    
    class part
    {
    public:
    	part(string s):ss(s),ii(10){}
    	part(int i,string s):ii(i),ss(s){}
    	void foo(const part& partn){ss=partn.ss;}
    	void print()
    	{
    		cout<<ii<<endl<<ss<<endl;
    	}
    private:
    	int ii;
    	string ss;
    }part1(100,"world");
    
    int main()
    {
    	part1.print();
    	string s="hello";
    	part1.foo(s);
    	part1.print();
    }
    

    23、可以用explicit修饰构造函数从而达到如下效果(explicit只允许出现在类的内部):

       23.1、如果构造函数是转换构造函数,此时将无法进行隐式转换。

       23.2、发生隐式转换的另一种情况是,当我们执行拷贝形式的初始化时(=)。此时,只能使用直接初始化,而不能将explicit构造函数用于拷贝形式的初始化。

    24、尽管编译器不会将explicit的构造函数用于隐式转换过程,但是可以显式的强制进行转换。

    part1.foo(part("hellio"));

    part1.foo(static_cast<part>"hello");

    25、标准库中的构造函数

       25.1、接受一个单参数的const char*的string构造函数不是explicit的。

    string s="hello";

    string s("hello");

       25.2、接收一个容量参数的vector构造函数是explicit的。

    vector<T> v(n);

    五、聚合类

    26、聚合类与C语言中的结构体很类似,它使得用户可以直接访问其成员,并且具有特殊的初始化语法形式。

    27、当一个类满足如下条件时,我们说它是聚合类:

       27.1、所有成员都是public的

       27.2、没有定义任何构造函数

       27.3、没有类内初始值

       27.4、没有基类,也没有virtual函数。

    28、可以用一个花括号括起来的成员初始值列表初始化聚合类的数据成员,初始值的顺序必须与声明的顺序一致。

    29、如果初始值列表中的元素个数少于类的成员数量,则靠后的成员被值初始化。初始值列表的元素个数绝对不能超过类的成员数量。

    六、字面值常量类

    此部分可参考——C++11中的constexpr

    30、数据成员都是字面值类型的聚合类是字面值常量类。

    31、如果一个类不是聚合列,但它符合下述要求,则它也是一个字面值常量类。

       31.1、数据成员都必须是字面值类型

       31.2、类必须至少含有一个constexpr构造函数(尽管构造函数不能是const的)

       31.3、如果一个数据成员含有类内初始值,则内置类型成员的初始值必须是一条常量表达式;或者如果成员属于某种类类型,则初始值必须使用成员自己的constexpr构造函数

       31.4、类必须使用析构函数的默认定义,该成员负责销毁类的对象。

    32、constexpr构造函数可以声明成=default的形式(或者是删除函数的形式)。否则,constexpr构造函数就必须既符合构造函数的要求(不能包含返回语句),又符合constexpr函数的要求(意味着它能拥有的唯一可执行语句就是返回语句)。综合这两点,constexpr构造函数体应该是空的。通过前置关键字constexpr就可以声明一个constexpr构造函数了。

    33、constexpr构造函数必须初始化所以数据成员,初始值要么使用constexpr构造函数,要么是一条常量表达式。

    34、constexpr构造函数用于生成constexpr对象以及constexpr函数的参数或返回类型。

    #include <iostream>
    using namespace std;
    #include <string>
    
    class part
    {
    public:
    	constexpr part(int i, int s) :ii(i), ss(s) {}
    	void print()
    	{
    		cout << ii << endl << ss << endl;
    	}
    	constexpr int poo()
    	{
    		return ss;
    	}
    private:
    	int ii;
    	int ss;
    	//只能使用字面值类型
    };
    
    int main()
    {
    	constexpr part p1(10, 20);
    	int data[p1.poo()];
    	cout << sizeof(data) << endl;
    }
    

     

    展开全文
  • 关于 C++ 默认构造函数几个误区

    千次阅读 2012-11-01 20:33:17
    C++新手一般两个常见的误解: 1.任何class如果没有定义default constructor,就会被合成一个来。 2.编译器合成出来的...1、每个必须至少有个构造函数,否则没法创建对象; 2、若programer没有提供任何构造

    C++新手一般有两个常见的误解:

    1.任何class如果没有定义default constructor,就会被合成一个来。

    2.编译器合成出来的default constructor会明确设定“class 内每个data member的默认值”。

    如你所见,没有一个是真的!

    C++的几条原则

    1、每个类必须至少有一个构造函数,否则没法创建对象;

    2、若programer没有提供任何构造函数,则C++提供一个默认的构造函数,该默认构造函数是无参构造函数,它仅负责创建对象,不做任何初始化的工作;

    3、只要programer定义了一个构造函数(不管是无参还是有参构造),C++就不再提供默认的默认构造函数。即如果为类定义了一个带参的构造函数,还想要无参构造函数,就必须自己定义;

    4、与变量定义类似,在用默认构造函数创建对象时,如果创建的是全局对象或静态对象,则对象的位模式全为0,否则,对象值是随机的。

    注:2所述,C++在某些情况下会提供默认构造函数,但在某些情况下并不会自动调用。实事上,当用户没有提供自定义的构造函数的时候,声明该类的对象,以及定义包含该对象的数组,都不会调用默认构造函数;但定义包含该对象的容器时,会自动调用默认的构造函数。

    举例如下:

    classStudent

    {

    public:

    //Student() : val(6){} // 1

    //Student(int val) : val(6){} // 2

    int val;

    };

     

    voidmain()

    {

    Students;

    cout<< s.val<<"first"<<endl;; // 编译通过,但运行时出错:the variable 's' is being used withoutbeing defined.

    // 说明没有调用默认构造函数

    Studentarr[4];

     arr[2]; // 编译通过,但运行出错:the variable 'arr' is being used without beingdefined.

    // 说明没有调用默认构造函数

    vector<Student>vec(5);

    cout<< vec[3].val <<"second"<< endl; //运行无误,但输出结果未定义(取决于编译器,可能是随机值或0

    // 说明调用了默认构造函数

    Student*ptr = new Student[4];

    cout<< ptr[1].val <<"third"<<endl; //运行无误,但输出结果未定义(取决于编译器,可能是随机值或0

    // 说明调用了默认构造函数

    Studentss = Student(); // 显示调用

    cout<< ss.val<<"forth"<<endl; // 运行无误,但输出结果未定义(取决于编译器,可能是随机值或0

    // 说明调用了默认构造函数

    getchar();

    }

    若将Student定义体中的注释1去掉,即自定义无参构造函数,则main函数中的几种形式的对象定义都会调用该自定义的无参构造函数。

    但只将注释2去掉,即自定义带参构造,而不提供无参构造,则main函数的几种形式的对象定义都将因为没有可用的默认构造函数而编译出错。


    关于两种默认构造函数

    在《C++ Annotated Reference Manual(ARM)[ELLIS90]》中的Section 12.1告诉我们:"Defaultconstructors...在需要的时候被编译器产生出来"。

    其实默认构造函数也是分为两类的:有用的、无用的。

    所谓有用的标准也是就默认构造函数会为我们的类做一些初始化操作。那么无用的就不会做任何工作,从而对我们的类也就没有任何意义。所以,我们通常所说的默认构造函数是指有用的默认构造函数,其英文名字叫nontrivial default constructor。

    那么到底什么时候编译器会为我们产生nontrivial default constructor呢?有下面四中情况:

    如果一个类里面某个成员对象有nontrivial default constructor,编译器就会为我们的类产生nontrivialdefault constructor。

    那么编译器这样做的理由是什么?

    答案是因为类成员对象有nontrivial default constructor,那么编译器就需要显式的来调用这个类成员对象的nontrivial default constructor。而编译器想显式的调用类成员对象的nontrivial default constructor,就需要自己来合成一些代码来调用。但是记住,编译器合成的nontrivial default constructor仅仅调用类成员对象的默认构造函数,而不对我们类里面的其它变量做任何初始化操作。

    也就是说,如果你想初始化类成员变量以外的变量例如一个int、一个String,那么必须自己定义默认构造函数来完成这些变量的初始化。而编译器会对你定义的默认构造函数做相应的扩展,从而调用类成员对象的nontrivial default constructor。

    如果一个派生类的基类有nontrivial default constructor,那么编译器会为派生类合成一个nontrivial default constructor。

    编译器这样的理由是:因为派生类被合成时需要显式调用基类的默认构造函数。

    如何一个类里面隐式的含有任何virtual function table(或vtbl)、pointer member(或vptr)。

    编译器这样做的理由很简单:因为这些vtbl或vptr需要编译器隐式(implicit)的合成出来,那么编译器就把合成动作放到了默认构造函数里面。所以编译器必须自己产生一个默认构造函数来完成这些操作。

    所以如果你的类里带有任何virtual function,那么编译器会为你合成一个默认构造函数。

    如果一个类虚继承于其它类。

    编译器这样做的理由和③类似:因为虚继承需要维护一个类似指针一样,可以动态的决定内存地址的东西(不同编译器对虚继承的实现不仅相同)。

    那么除了以上四种情况,编译器并不会为我们的类产生默认构造函数。

    所以编程中切忌想当然,要明白哪些事情是编译器做的,哪些事情需要程序员来完成的。就像堆所占用的资源需要程序员自己来释放,而栈空间是编译器管理的一样。

    只有如此,才能编写出质量更高的代码。


    展开全文
  • 构造函数和析构函数

    千次阅读 2018-07-29 17:00:05
    c++中的可以定义与类名相同的特殊成员函数,这种那个与类名相同的成员函数叫做...拷贝构造函数:当中没有定义拷贝构造函数时,所有有一个默认的拷贝构造函数,拷贝构造函数只是做简单的赋值 调用时机: ...

    c++中的类可以定义与类名相同的特殊成员函数,这种那个与类名相同的成员函数叫做构造函数,

    构造函数分为有参数和无参数的,没有任何返回值类型的声明。

    构造函数的调用分为

    自动调用:一般情况下c++编译器会自动调用构造函数

    手动调用:在一些情况下则需要手动调用构造函数

    拷贝构造函数:当类中没有定义拷贝构造函数时,所有类都有一个默认的拷贝构造函数,拷贝构造函数只是做简单的赋值

    调用时机:

    1、Test t2 = t1;   // 用对象 t1 去初始化t2
    2、Test t2(t0);    // 用对象 t0 去初始化t2
    3、PrintObj(t0);   // 做函数参数的时候
    4、t1 = test();       // 函数返回值返回对象

    拷贝构造是确确实实构造一个新的对象,并给新对象的私有成员赋上参数对象的私有成员的值,新构造的对象和参数对象地址是不一样的,所以如果该类中有一个私有成员是指向堆中某一块内存,如果仅仅对该私有成员进行浅拷贝,那么会出现多个指针指向堆中同一块内存,这是会出现问题,如果那块内存被释放了,就会出现其他指针指向一块被释放的内存,出现未定义的值的问题,如果深拷贝,就不会出现问题,因为深拷贝,不会出现指向堆中同一块内存的问题,因为每一次拷贝,都会开辟新的内存供对象存放其值。

    #include <iostream>
    #include <string.h>
    using namespace std;
    
    class A
    {
    private:
        int* n;
    
    public:
        A()
        {
            n = new int[10];
            n[0] = 1;
            cout<<"constructor is called\n";
        }
    
        /*A(const A& a)
        {
            n = a.n; //delete两次同一块内存会出错 
            cout<<"copy constructor is called\n";
        }*/
        
        A(const A& a)
        {
            n = new int[10];
            memcpy(n, a.n, 10);  //通过按字节拷贝,将堆中一块内存存储到另一块内存
            cout<<"copy constructor is called\n";
        }
    
        ~A()
        {
            cout<<"destructor is called\n";
            delete n;
        }
    
        void get()
        {
            cout<<"n[0]: "<<n[0]<<endl;
        }
    };
    
    
    int main()
    {
        A* a = new A();
        A b = *a;
        delete a;
    
        b.get();
    
        return 0;
    }

    new和delete:

    在C语言中是利用库函数malloc和free来分配和撤销内存空间的。C++提供了较简便而功能较强的运算符new和delete来取代malloc和free函数。new和delete是运算符,不是函数,因此执行效率高。

    几个例子:

    #include<iostream>
    using namespace std;
    int main()
    {
    	int *p1=(int *)malloc(sizeof(int));
    	*p1=1;
    	free(p1);
    	
    	int *p2=(int *)malloc(sizeof(int)*10);
    	for(int i=0;i<10;i++)
    	{
    		*(p2+i)=i;
    	}
    	free(p2);
    	
    	int *p3=new int;
    	cout<<*p3<<endl;
    	delete p3;
    	
    	int *p4=new int [10];
    	for(int i=0;i<10;i++)
    	{
    		cout<<p4[i]<<endl;
    	}
    	delete p4;
    };
    

     

    1)当类中没有定义任何一个构造函数时,c++编译器会提供默认无参构造函数和默认拷贝构造函数
    2)当类中定义了拷贝构造函数时,c++编译器不会提供无参数构造函数
    3)当类中定义了任意的非拷贝构造函数(即:当类中提供了有参构造函数或无参构造函数),c++编译器不会提供默认无参构造函数
    4 )默认拷贝构造函数成员变量简单赋值

    注意的是,只要你写了构造函数,那么你必须要用

    构造函数可以有多个,但是析构函数只有一个,

    1)C++中的类可以定义一个特殊的成员函数清理对象,这个特殊的成员函数叫做析构函数
    语法:

    class A
    {
    public:
        A()
        {
            std::cout << "我是构造函数,被调用了" << std::endl;
    
        }
        ~A()
        {
            std::cout << "我是析构函数,被调用了" << std::endl;
        }
    };


    2)析构函数没有参数也没有任何返回类型的声明
    3)析构函数在对象销毁时自动被调用

     

     

     

    展开全文
  • 继承中构造函数和析构函数的调用 现在,个类的定义如下 class CA { public:  CA(){cout    ~CA(){cout }; class CB:public CA { public:  CB(){cout    ~CB(){cout }; ...
  • 名字与类名相同,创建类型对象时,由编译器自动调用,在对象的声明周期内只调用一次,以保证每个数据成员都有一个合适的初始值。   2、构造函数的特性 (1)函数名与类名相同; (2)没有返回值; (3)...
  • C++构造函数概念及使用方法

    千次阅读 多人点赞 2020-07-12 16:31:36
    在c++的中,构造函数是一种特殊的成员函数,在每次创建创建一个类的时候会默认调用构造函数进行初始化工作。 构造函数用来完成一些必要的初始化工作,构造函数之后,就无需再单独写初始化函数,并且也不必担心...
  • 必须在派生类构造函数中初始化的种情况 ...基类的构造函数全是参数的,派生必须至少实现一个基类的构造函数,例如Qt中常见的: explicit MainWindow(QWidget* parent=0); //QMainWindow构造函数都...
  • 构造函数+初始化函数

    千次阅读 2011-04-28 14:51:00
    曾经一位Java程序员对我说,他现在越来越频繁地采用构造函数+初始化函数的方式来准备一个对象,而不是直接在构造函数里将所有资源都准备好。谈及原因,他说道,他在GUI开发当中经常要在子类的初始化过程中调用父类...
  • 构造函数与普通函数的区别

    千次阅读 2017-04-18 19:01:06
    本篇博文主要是为新手、对java语言感兴趣的人和那些没有系统学习过java基础知识的人进行一个总结,在文章中对构造函数进行了较为详细的说明和讨论,也包含了我个人对于java面向对象中构造函数的一些看法。...
  • C++的构造函数、初始化方式

    千次阅读 2019-05-08 11:24:30
    当我们自定义一个类的时候,需要创建构造函数。 1、构造函数的作用:用来初始化对象空间。编译系统在创建对象的时候,会申请内存空间,然后自动调用构造函数,完成对象的初始化操作。 2、构造函数的种类...
  • C++为什么要有构造函数和析构函数

    千次阅读 2012-10-22 10:23:23
    C++为什么要有构造函数和析构函数 在我们过去学习C语言编程的时候,我们通常生成的变量都是放在栈区里(auto存储类型)。然而,真正处理实际问题的程序却常常将变量或数组生成在堆区里。 假设我们定义了一个...
  • 浅析拷贝构造函数

    千次阅读 2006-05-24 20:46:00
    这篇文章,主要是受Jinhao (辣子... 拷贝构造函数的名字和类名是一样的 [错] 中只有一个拷贝构造函数 [错] 拷贝构造函数可以多个参数 [对] 拷贝构造函数无任何函数类型 [错]在这里我不想讨论以上问题的正确与错
  • C#构造函数的声明、重载与继承调用

    千次阅读 2015-06-03 21:26:14
    今天小智终于开始写C#的博客了,c语言属于面向过程的编程语言,而c#则属于面向对象的编程语言,相信看此片博客的同伴们应该已经...1.构造函数的主要作用是在创建对象(声明对象)时初始化对象,一个类定义至少有一个
  • Android自定义view的三个构造函数理解

    千次阅读 2016-04-23 11:46:21
    怎么理解这三个函数?为什么要写三?不同的都什么作用?请大神能够深入简出说说.... 全选复制放进笔记public MyView(Context context) { super(context); // TODO Auto-generated constructor stub } } ·再...
  • C++11新特性(19)- constexpr构造函数

    千次阅读 2018-05-08 20:02:17
    聚合满足以下条件:所有成员都是public的没有定义构造函数没有内初始值没有基类,也没有虚函数怎么理解呢?首先,看来看去聚合其实就是一个C结构体;其次,聚合这个词,应该是相对组合的,表明了成员和之间...
  • 特别的,一个类是可以个构造函数,可以根据参数个数的不同或者参数类型的不同来区分它们,即为构造函数的重载。 构造方法是一个特殊的成员,在实例化时会自动调用,其构造方法定义格式如下: 修饰符 方法...
  • C++ 的默认函数

    千次阅读 2016-12-19 16:24:05
    用户自定义一个类,简单的可以看成是一个新的类型,...一个没有任何成员函数的,其至少有如下四个默认函数 默认构造函数 默认拷贝构造函数 默认“=”运算符重载函数 析构函数 既然是默认函数,那也就是说即便里面
  • C++构造函数与析构函数知多少

    千次阅读 2011-09-30 11:27:41
    众所周知,几乎所有的面向对象的编程语言都保护构造函数与析构函数,好学者就要举手了,啥情况啊,Java里面不就没有析构函数嘛。好吧,你问倒我了,不过可以认为Java的垃圾自动回收机制实现了对象析构的功能。管他呢...
  • 继承与派生,多继承,函数重载,构造函数调用顺序
  • 因此该类至少应包含两“私有”成员变量, 还应具有如下成员函数: 1)多种构造函数; 2)析构函数; 3)取实部和虚部; 4)求模; 5)求主幅角; 6)单目运算:++等; 7)双目运算:重构运算符操作+ , - , x ...
  • )、读后感  在我参加工作两年多的时候,工作不算很忙了,《深入理解C++对象模型》开始进入我的视野;或许是因为我要从Symbian.C++ 转向iOS Objective-C,并开始思考语言本身的一些东西的缘故。  其实在一年前,...
  • Java要求,如果您在构造函数中调用this()或super(),则它必须是第条语句。 为什么? 例如: public class MyClass { public MyCla
  • 泛型:转移构造函数

    千次阅读 2004-07-09 14:11:00
    泛型:转移构造函数 Andrei Alexandrescu 我想你们知道得很清楚,创建,拷贝,并摧毁临时对象是你的C++编译器爱做的事,临时对象在内部被创建,不幸的是这极大影响到了C++程序的执行效率。实际上,临时对象是C++程序...
  • 构造函数和析构函数可以是私有或保护的吗?   我的书稿还对流行的教科书存在的一些问题进行了探讨,笔者相信,连教科书都会出现的问题一定具有探讨的必要。 在书稿中隐去了发生问题的教科书的名字,但是在...
  • 详解C++中的六默认成员函数

    千次阅读 2018-11-30 16:17:22
    在C++98中,如果一个类中什么都没有,简称为空,系统会自动生成六个默认的成员函数,构造函数、析构函数、拷贝构造函数、赋值运算符重载、&amp;操作符重载、const,在C++11中又加入了控制默认函数(=default ,...
  • 现在,个类的定义如下 class CA { public:  CA(){cout    ~CA(){cout }; class CB:public CA { public:  CB(){cout    ~CB(){cout }; class CC:public CB { public:  CC...
  • 前面篇blog提到过对含有指针成员变量的来说,使用默认的拷贝构造和赋值操作是不安全的,具体的原因是默认的函数都属于浅拷贝,所谓浅拷贝就是指只对指针本身进行拷贝操作而对于指针所指向的内容不进行任何操作,...
  • 现在我们一个会立即执行的方法,还有一个相对安全的执行上下文,其中还包含window、$和undefined变量(这几个变量还是可能在这个脚本被执行前就被重新赋值,不过现在的可能性要小的多了)。现在我们已经做得...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,362
精华内容 51,744
关键字:

一个类至少有几个构造函数