精华内容
下载资源
问答
  • C++ 重载构造函数

    万次阅读 2016-05-15 21:17:03
    1. 重载构造函数  构造函数也具备了重载的特性。 #include using namespace std; class rectangle { public: rectangle(){cout rectangle(int l,int w){length=l;width=w;cout  length * width ...

     1. 重载构造函数

      构造函数也具备了重载的特性。

    #include <iostream>
    using namespace std;
    class rectangle
    {
    public:
    rectangle(){cout<<"构造一个长方形a!\n";}
    rectangle(int l,int w){length=l;width=w;cout<<"长方形b的面积为:" << 
           length * width <<endl;}
    rectangle(int l,int w,int h){length=l;width=w;height=h;cout<<"长方体c的体积为:" <<length*width*height<<endl;}
    private:
    int length;
    int width;
    int height;
    };
    void main()
    {
    rectangle a;
    rectangle b(3,4);
    rectangle c(3,4,10);
    }

    2. 成员变量的初始化

    1)对成员变量进行初始化有许多方式,一个是在构造函数体中进行难过初始化。

    对象a在构造的同事调用构造函数,构造函数通过接收参数将参数传递到函数体中,然后又分别赋给私有变量length和width,完成了对成员变量的初始化工作。


    2)另外还有一种方式就是在构造函数的函数头进行初始化。

    rectangle () :length(3),width(4){}

      在构造函数的右边有个冒号(:),然后是成员变量的名称和一对小括号(),小括号中要是初始化的值或者表达式。如果对多个成员进行初始化,那么要用逗号将他们隔开,最后

    一对大括号{},大括号中就是函数索要执行的功能。


      //const成员或者引用成员都是不可赋值的,因此只能进行初始化。
    #include <iostream>
    using namespace std;
    class A
    {
    public:
      //A(int a,int b){num=a;total=b;} //错,不能进行赋值
    A(int a,int b):num(a),total(b){}
    private:
      const int num;
      int &total;
    };
    int main()
    {
      A a(3,4);
      return 0;
    }




    展开全文
  • 构造函数分为默认构造函数和重载构造函数。默认构造函数分为两类 1.默认构造函数 1)定义一个无参数的默认构造函数; 2)定义所有参数都有默认值的默认构造函数 2.重载构造函数 在一个类中可以定义多个构造函数,...

    本文主要总结了默认构造函数的相关用法和构造函数重载,旨在能够对平时的项目开发起到一定的夯实基本功的作用,言简意赅,一目了然。

    一、构造函数的定义

    构造函数是用来做什么?就是该类对象被创建时,编译器为对象分配内存空间,并自动调用该构造函数,由构造函数完成数据成员的初始化工作。

    二、构造函数的分类

    构造函数分为默认构造函数和重载构造函数。默认构造函数分为两类

    • 1.默认构造函数
      1)定义一个无参数的默认构造函数;
      2)定义所有参数都有默认值的默认构造函数
    • 2.重载构造函数
      在一个类中可以定义多个构造函数,以便提供不同的初始化的方法,供用户选用。这些构造函数具有相同的名字,而参数的个数或参数的类型不相同。这称为构造函数的重载。

    三、默认构造函数与重载构造函数的用法

    1.当不需要利用重载构造函数时,写构造函数只需要两种默认构造中的一个即可
    ①例子:第一种默认构造函数

    class testClass {
    public :
        testClass();//第一种不带参数的默认构造函数---------
        testClass(int a, char b);//构造函数
        testClass(int a = 0, char b = 'c');//参数都有默认值的默认构造函数-------
    
    private:
        int m_a;
        char m_b;
    };
    

    注意!第一种默认构造函数后面常常要加一个重载构造函数

    ②例子:第二种默认构造函数

    #include <iostream> 
    using namespace std; 
    class Box {   
    public :   
        Box(int h=10,int w=10,int len=10); //在声明构造函数时指定默认参数--默认构造函数
        int volume( );   
    private :   
        int height;   
        int width;   
        int length; 
    }; 
    Box::Box(int h,int w,int len) 
    {   
        height=h;   
        width=w;   
        length=len; 
    }
    //或者
    //Box::Box(int h,int w,int len):height(h),width(w),length(len)
    //{
    //
    //}
    
    int Box::volume( )
    {   
        return (height*width*length);
    } 
    
    int main( ) 
    {  
        Box box1; //没有给实参   
        cout<<"The volume of box1 is "<<box1.volume( )<<endl;   
    
        Box box2(15); //只给定一个实参   
        cout<<"The volume of box2 is "<<box2.volume( )<<endl;   
    
        Box box3(15,30); //只给定2个实参   
        cout<<"The volume of box3 is "<<box3.volume( )<<endl; 
    
        Box box4(15,30,20); //给定3个实参  
        cout<<"The volume of box4 is "<<box4.volume( )<<endl;  
        return 0; 
    }
    

    2.当需要设置重载构造函数时,前面必须先声明默认构造函数(二选一)

    例子:

    #include <iostream> 
    using namespace std; 
    class Box {   
    public : 
        Box(); //声明一个无参的构造函数   
        //Box(int h); //有1个参数的构造函数 
        //Box(int h,int w); //有两个参数的构造函数 
        Box(int h, int w, int len) :height(h), width(w), length(len);//声明一个有参的构造函数,用参数的初始化表对数据成员初始化
        int volume( );   
    private :   
        int height;   
        int width;   
        int length; 
    }; 
    Box::Box() //定义一个无参的构造函数 
    {   
        height=10; 
        width=10; 
        length=10; 
    } 
    //Box::Box(int h)
    //{
    //
    //}
    //
    //Box::Box(int h,int w)
    //{
    //
    //}
    
    Box::Box(int h, int w, int len) :height(h), width(w), length(len)
    {
    }
    
    int Box::volume( )
    {   
        return (height*width*length); 
    } 
    
    int main( ) 
    {   
        Box box1; //建立对象box1,不指定实参  
        cout<<"The volume of box1 is "<<box1.volume( )<<endl;   
        Box box4(15,30,25); //建立对象box4,指定3个实参   
        cout<<"The volume of box4 is "<<box4.volume( )<<endl;   
        return 0; 
    } 
    
    

    四、建立类后调用构造函数的注意事项

    ①假如定义了一个类为Teather ,则定义一个Teather这个类的变量时,就会自动调用这个类的构造函数
    ②调用构造函数时不必给出实参的构造函数,称为第一种默认构造函数(default constructor)。显然,无参的构造函数属于第一种默认构造函数。一个类只能有一个默认构造函数。如果在建立对象时选用的是无参构造函数,应注意正确书写定义对象的语句
    ③如果要用到重载构造函数的话,在定义了一个类为Teather ,则定义一个Teather这个类的变量时,变量的形式应该要和默认构造函数的形式相同,为有参的就要写有参,无参就为无参
    ④尽管在一个类中可以包含多个重载构造函数,但是对于每一个对象来说,建立对象时只执行其中一个重载构造函数,并非每个构造函数都被执行

    展开全文
  • C++中一般创建对象,拷贝或赋值的方式有构造函数,拷贝构造函数,赋值函数这三种方法。下面就详细比较下三者之间的区别以及它们的具体实现 1.构造函数 构造函数是一种特殊的类成员函数,是当创建一个类的对象时,它...
  • C++构造函数重载

    2013-04-02 19:25:45
    重载构造函数,调用成员函数,供C++初学者理解构造函数重载的概念
  • 文章目录C++重载构造函数的互相调用初始化成员变量的问题不能直接互相调用的重载构造函数使用一个private的函数初始化成员变量使用带有默认参数的构造函数使用placement new运算符调用重载构造函数使用C++11的委托...

    C++中重载构造函数的互相调用初始化成员变量的问题

    写一个类的时候,我们可能会希望有多重不同的初始化方式,此时就用到了重载构造函数。例如:

    class TestConstructor
    {
    public:
    	int value;
    
    public:
    	TestConstructor();
    	TestConstructor(int);
    };
    

    这样我们可以有两种方式来初始化一个TestConstructor对象。
    两个重载构造函数实现的代码可以分别是:

    TestConstructor::TestConstructor()
    {
    	this->value = 10;
    }
        		 
    TestConstructor::TestConstructor(int value)
    {
    	this->value = value;
    }
    

    不能直接互相调用的重载构造函数

    对于上边的这个无参构造函数,我们可以直接初始化value为10,但是如果参数很多,重载构造函数很多,那么就不可能每个都写一遍一模一样的赋值操作(其实也可以,就是有些丑,而且如果发生改动,则有可能会因为疏忽而出错)。所以,我们希望能够减少重复的赋值操作,例如调用其他的重载构造函数,就像这样,

    TestConstructor::TestConstructor()
    {
    	TestConstructor(10);
    }
    
    TestConstructor::TestConstructor(int value)
    {
    	this->value = value;
    }
    

    但是这样可以嘛?我们试一下,为了方便查看实际生成的对象,我们在构造函数里输出对象的指针地址。

    #include <iostream>
    
    using namespace std;
    
    class TestConstructor
    {
    public:
    	int value;
    
    public:
    	TestConstructor();
    	TestConstructor(int);
    };
    
    TestConstructor::TestConstructor()
    {
    	TestConstructor(10);
    	cout << "constructor1:" << this << endl;
    }
    
    TestConstructor::TestConstructor(int value)
    {
    	this->value = value;
    	cout << "constructor2:" << this << endl;
    }
    
    int main()
    {
    	TestConstructor *t = new TestConstructor();
    	cout << t->value << endl;
    	cout << t << endl;
    	delete t;
    
    	return 0;
    }
    

    运行结果:
    constructor2:0x7fff81eb3494
    constructor1:0x5586774bce70
    0
    0x5586774bce70

    可以看出,在构造函数中调用重载构造函数时,被调用的构造函数重新创建了一个新的对象,所以不能用这种方法。

    使用一个private的函数初始化成员变量

    在我之前的项目中,为了解决这个问题,我采用了另外写一个private的函数的方法,把一些需要反复初始化的部分扔进了一个private的函数里。例如,

    class TestConstructor
    {
    private:
    	void initialize(int);
    
    public:
    	int value;
    
    public:
    	TestConstructor();
    	TestConstructor(int);
    };
    
    void TestConstructor::initialize(int value)
    {
    	this->value = value;
    }
    
    TestConstructor::TestConstructor()
    {
    	this->initialize(10);
    	cout << "constructor1:" << this << endl;
    }
    
    TestConstructor::TestConstructor(int value)
    {
    	this->initialize(value);
    	cout << "constructor2:" << this << endl;
    }
    

    这个当然是一种解决方案。不过,最近用cppcheck analysis的时候,总是提示我 Member variable "xxx" is not initialized in the constructor., 这促使我思考了一下是否有更好的方法解决该问题。

    使用带有默认参数的构造函数

    在C++的函数声明中可以设置默认参数,所以一种可行的方法就是用含默认参数的构造函数来代替重载构造函数。如:

    class TestConstructor
    {
    public:
    	int value;
    
    public:
    	TestConstructor(int value = 10);
    };
    
    TestConstructor::TestConstructor(int value)
    {
    	this->value = value;
    }
    
    

    (NOTE:注意默认参数通常放在函数声明上,并且只能写一次,即声明写了,定义部分就不能再写)

    使用placement new运算符调用重载构造函数

    C++提供在预先分配好的内存上创建对象的方法,即placement new运算符。在C++中,构造函数的执行实际上分为两个阶段,分别是初始化阶段和计算阶段,其中初始化阶段先于计算阶段。在进入计算阶段前,所有的成员变量都已经完成了初始化,所以内存也都已经按需分配好,此时我们可以在this指针指向的这块内存上调用重载构造函数创建一个新的对象,覆盖掉原来的对象。

    #include <iostream>
    
    using namespace std;
    
    class TestConstructor
    {
    public:
    	int value;
    
    public:
    	TestConstructor();
    	TestConstructor(int value);
    };
    
    TestConstructor::TestConstructor()
    {
    	new (this)TestConstructor(10);
    	cout << "constructor1:" << this << endl;
    }
    
    TestConstructor::TestConstructor(int value)
    {
    	this->value = value;
    	cout << "constructor2:" << this << endl;
    }
    
    int main()
    {
    	TestConstructor *t = new TestConstructor();
    	cout << t->value << endl;
    	cout << t << endl;
    	delete t;
    
    	return 0;
    }
    
    

    运行结果:
    constructor2:0x55bece811e70
    constructor1:0x55bece811e70
    10
    0x55bece811e70

    使用C++11的委托构造函数(在初始化列表位置调用)

    据我了解这是C++11中加入的功能,名为委托构造函数。其将重载构造函数放置在初始化列表的位置调用。

    #include <iostream>
    
    using namespace std;
    
    class TestConstructor
    {
    public:
    	int value;
    
    public:
    	TestConstructor();
    	TestConstructor(int);
    };
    
    TestConstructor::TestConstructor():TestConstructor(10)
    {
    	cout <<"constructor1:"<< this << endl;
    }
        		 
    TestConstructor::TestConstructor(int value)
    {
    	this->value = value;
    	cout <<"constructor2:"<<this << endl;
    }
    
    int main()
    {
    	TestConstructor *t = new TestConstructor();
    	cout << t->value << endl;
    	cout << t << endl;
    	delete t;
    
    	return 0;
    }
    

    运行结果:
    constructor2:0x5594d644de70
    constructor1:0x5594d644de70
    10
    0x5594d644de70

    ##总结
    对于重载构造函数的互相调用初始化成员变量的问题,我们可以

    1. 使用一个私有函数初始化成员变量
    2. 使用带有默认参数的构造函数
    3. 使用placement new运算符调用重载构造函数
    4. 使用C++11的委托构造函数(在初始化列表位置调用)
    展开全文
  • C++:构造函数重载

    千次阅读 2019-09-21 10:53:30
    构造函数指的是函数名和类名是相同的。 #include<iostream> using namespace std; class Rectangle{ public: Rectangle(); Rectangle(int); Rectangle(int,int); int cul();...

    函数重载指的是函数名相同执行相同的功能的函数,但是形参名,形参个数是不相同的。
    构造函数指的是函数名和类名是相同的函数。构造函数是在对象建立时自动调用的函数。如果在定义类的时候没有在类里面定义构造函数,那么系统会自动的生成一个构造函数,但是这个构造函数里的函数体是空的,所以该构造函数不执行任何的功能。

    #include<iostream>
    using namespace std;
    class Rectangle{
    	public:
    		Rectangle();
    		Rectangle(int);
    		Rectangle(int,int);  
    		int cul();
    	private:
    		int length;
    		int width;
    };
    Rectangle::Rectangle(){
    	length=1;
    	width=1;
    }
    Rectangle::Rectangle(int w){
    	length=width=w;
    }
    Rectangle::Rectangle(int l,int w){
    	length=l;
    	width=w;
    }
    int Rectangle::cul(){
    	return length*width;
    }
    int main(){
        Rectangle rec1;
        cout<<rec1.cul()<<endl;
        Rectangle rec2(2);
        cout<<rec2.cul()<<endl;
        Rectangle rec3(10,6);
        cout<<rec3.cul()<<endl;
        return 0;
    }
    
    

    解释:
    (1)在类里声明了构造函数,构造函数和类是同名的。
    (2)因为本代码在类外定义了函数,语法与在类的内部定义函数不同。
    在类的内部定义函数:
    返回值类型 函数名(形参){
    }
    int add(int a,int b){
    }
    在类外部定义函数:
    返回值类型 类名::函数名(形参){
    }
    int Rectangle::add(int a,int b){
    }

    但是如果在类里面定义了一个所有参数都带默认值的构造函数,这个时候就不能再重新定义重载的构造函数。所以尽量使重载构造函数与带默认值的构造函数不同时出现。

    展开全文
  • C++构造函数重载

    2020-09-03 14:10:56
    主要介绍了C++构造函数重载的相关资料,十分的详细,需要的朋友可以参考下
  • C++构造函数的默认参数 和普通函数一样,构造函数中参数的值既可以通过实参传递,也可以指定为某些默认值,即如果用户不指定实参值,编译系统就使形参取默认值。 【例】 #include using namespace std; class Box...
  • 1.必须这样做:如果我们有一个类成员,它本身是一个类或者是一个结构,而且这个成员它只有一个带参数的构造函数,而没有默认构造函数,这时要对这个类成员进行初始化,就必须调用这个类成员的带参数的构造函数,如果...
  • 面向对象程序设计,即C++语言,类。构造函数的显示调用+构造函数重载,文件里面有详细的注释。
  • 您可能感兴趣的文章:浅谈c++构造函数问题,初始化和赋值问题详解C++ 拷贝构造函数和赋值运算符详解C++中对构造函数和赋值运算符的复制和移动操作C++中复制构造函数重载赋值操作符总结深入C++构造函数、拷贝构造...
  • C++中复制控制是一个比较重要的话题,主要包括复制构造函数重载赋值操作符、析构函数这三部分,这三个函数是一致的,如果需要手动定义了其中了一个,那么另外的两个也需要定义,通常在存在指针或者前期相关操作...
  • 重载构造函数

    2014-01-14 11:47:02
    重载构造函数,通过小代码段实例来讲解、分析重载构造函数
  • C++ 中,如果某个类型未声明它本身,则编译器将自动为该类型生成默认构造函数、复制构造函数、复制赋值运算符和析构函数。这些函数称为特殊成员函数,它们使 C++ 中的简单用户定义类型的行为如同 C 中的结构。也...
  • C++ 拷贝构造函数和赋值构造函数

    万次阅读 多人点赞 2019-04-06 16:43:35
    C++中复制控制是一个比较重要的话题,主要包括复制构造函数重载赋值操作符、析构函数这三部分,这三个函数是一致的,如果类需要析构函数,则它也需要复制操作符 和 复制构造函数,这个规则被称为 C++的“三法则...
  • 同时使用构造函数和运算符重载时,又在运算符函数形参中加了引用,导致编译不通过… c++的标准规定:非const的引用不能指向临时对象,而转换构造函数创建的是一个临时对象,故编译不通过 一种方法是把引用去掉就能...
  • C++拷贝构造函数 等于号重载
  • 主要介绍了C++中复制构造函数重载赋值操作符总结,本文对复制构造函数重载赋值操作符的定义、调用时机、实现要点、细节等做了总结,需要的朋友可以参考下
  • C++静态构造函数

    千次阅读 2019-02-21 23:42:28
    C++静态构造函数 如果数据成员被声明为static,那么它在编译时就必须被初始化。仅含static的则放在类之外,实现文件之中;同时含有const的则放在类之内,直接跟在数据的定义之后。 在实际代码编写中碰到的问题是:...
  • C++构造函数和默认构造函数详解

    万次阅读 多人点赞 2019-04-07 15:19:45
    C++构造函数和默认构造函数 今天学习c++时突然感觉自己对构造函数和默认构造函数的区别有些分不清,于是查找了各大网站将资料汇总一下,供自己和其他朋友们参考。 构造函数c++的类在构造对象时调用的函数,此...
  • c++ 构造函数详解

    万次阅读 多人点赞 2019-05-31 17:20:58
    c++构造函数详解。(构造函数的分类、拷贝构造函数
  • C++中, 构造函数,拷贝构造函数,析构函数和赋值函数(赋值运算符重载)是最基本不过的需要掌握的知识。 但是如果我问你“拷贝构造函数的参数为什么必须使用引用类型?”这个问题, 你会怎么回答? 或许你会回答...
  • 一、提供默认赋值运算符重载函数的时机 当程序没有显示地提供一个以本类或者本类的引用为参数的赋值运算符重载函数时,编译器会自动生成这样一个赋值运算符重载函数。#include using namespace std;class Data { ...
  • 首先从构造函数说起,在C++面向对象的设计中,每一个对象代表一个抽象集合的实体,此时每一个实体在当前运行的进程中是需要对应的内存空间,即对象存在则有空间。为此,C++引入构造函数来实例化对象,并让编译器为该...
  • 详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数  编写类String 的构造函数、析构函数和赋值函数,已知类String 的原型为: class String { public: String(const char *str = NULL); // 普通...
  • 2.重载构造函数。修改上题,一种构造函数用整型变量记录矩形的长和宽,另一种构造函数用double型记录矩形的长和宽,然后完成成员函数及主函数。 Class Rect {public: int Area_int(); double Area_double(); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 137,165
精华内容 54,866
关键字:

c++重载构造函数

c++ 订阅