精华内容
下载资源
问答
  • 文章目录前言一、委托构造函数是什么?二、使用方式1.函数形式总结 前言 C++11新标准允许用户定义一个委托构造函数,来使用该类的其他构造函数执行自己的初始化过程,这样做的好处是是可以让代码更简洁,节省重复的...


    前言

    C++11新标准允许用户定义一个委托构造函数,来使用该类的其他构造函数执行自己的初始化过程,这样做的好处是是可以让代码更简洁,节省重复的代码。


    一、委托构造函数是什么?

    委托构造函数是C++11新允许的一种构造函数类型,区别于普通的构造函数,它可以使用所属类里的其他构造函数,类似于功能外包。

    二、使用方式

    1.函数形式

    代码如下(示例):

    class circle
    	{
    	public:
    		circle(int r,string c):radius(r),color(c){}
    		circle():circle(5,"red")
    		{ cout <<1<< "the radius is" << radius << " " << "the color is" << color << endl; }
    		circle(string c) :circle(5, c) 
    		{ cout <<2<< "the radius is" << radius << " " << "the color is" << color << endl; }
    		circle(istream& is) :circle()
    		{
    			is >> radius >> color;
    			cout << 3 << "the radius is" << radius << " " << "the color is" << color << endl;
    		}
    	private:
    		int radius;
    		string color;
    	};
    

    这个示例里除了第一个构造函数,余下的三个都委托了他们的工作。
    第一个构造函数接受两个实参,用实参初始化数据成员,它不是委托构造函数。
    第二个是我们定义的默认构造函数,它委托第一个双参数的构造函数完成初始化过程,并且输出自己的属性值。
    第三个接受一个string实参的构造函数同样委托给了双参数的构造函数。
    第四个接受istream& 的构造函数也是委托构造函数,它委托给了默认构造函数,默认构造函数又接着委托给了双参数构造函数。

    int main()
    {
    	circle C1;
    	circle C2("green");
    	circle C3(cin);
    	return 0;
    }
    

    我们创建了三个对象,分别是使用了默认构造函数C1和接受一个string的构造函数的C2,以及委托了默认构造函数的C3,为了便于区分,第一次运行我们将屏蔽C3,第二次运行将屏蔽C1,C2,运行结果如下:
    这是屏蔽C3的运行结果
    我们可以看到,在创建C1时,双参数的构造函数被调用,实现了C1的初始化;创建C2时,双参数的构造函数同样被调用,完成了C2的初始化。
    在这里插入图片描述
    C3的创建比较特别,我们不止使用了一个委托构造函数
    1.接受istream&的构造函数本身就是构造函数,它的初始化工作委托给了默认构造函数
    2.默认构造函数本身也是委托构造函数,它又委托给了双参数的构造函数
    我们可以看到,第一行输出的是默认构造函数的内容,而我们输入了6和“white”后,实现了C3的初始化,说明委托构造函数多层嵌套时,执行顺序遵循栈的方式,最后被调用的函数的函数体代码最先被执行,然后控制权才会交还给委托者的函数体。

    总结

    委托构造函数的主要注意点就是它的使用方式和多层嵌套时的函数体执行顺序。

    展开全文
  • 委托构造函数什么是委托构造函数为什么要有委托构造函数?代码讲解注意事项参考链接 什么是委托构造函数 当我还不知道这个东西的时候,看到名字,顾名思义,我理解为委托其他构造函数帮忙构造。 这和定义也是相近的...

    什么是委托构造函数

    当我还不知道这个东西的时候,看到名字,顾名思义,我理解为委托其他构造函数帮忙构造。

    这和定义也是相近的!

    C++11 引入了委托构造的概念,这使得构造函数可以在同一个类中一个构造函数调用另一个构造函 数,从而达到简化代码的目的

    为什么要有委托构造函数?

    避免你有多个参数表不同但是逻辑相近(或者有公共部分)的构造函数的时候,一个逻辑写好几遍造成代码重复。

    这里要更好的理解,需要将一个故事

    如图1, 班主任要求A、B、C三位同学完成将各自资料送交办公室任务.(C++中初始化成员) ,虽然三位同学手中的资料不同(各成员列表), 但是需要完成的操作是相同的(初始化), 都是送往办公室。按照C++98的做法, 则需要A、B、C三位同学各自重复相同操作。这显示是不必要的. 对于C++11, 完全可以将这个工作委托给一个同学(充当目标构造函数, 后面会专门将到)去间接完成, 这样便省去了大量的重复性劳动。

    在这里插入图片描述

    委托构造函数也是构造函数, 因此, 构造函数的特性都适合委托构造函数, 比如: 没有返回值, 可以有一个或多个参数, 有函数体等。委托构造函数也有一个成员初始值列表和函数体。 在委托构造函数内, 成员初始值列表的唯一入口便是类名本身。然后紧接着是以圆括号围起来的参数列表, 这些参数列表必须与类中的另外一个构造函数相匹配。

    代码讲解

    #include"entrusted_construction.h"
    
    
    /*******************************************************************************************************
    //委托构造函数
    C++11 引入了委托构造的概念,这使得构造函数可以在同一个类中一个构造函数调用另一个构造函
    数,从而达到简化代码的目的。
    *******************************************************************************************************/
    
    #include <iostream>
    class Base 
    {
    public:
    	int value1;
    	int value2;
    	Base()    //目标构造函数
    	{
    		value1 = 1;
    	}
    	Base(int value) : Base()  //委托构造函数
    	{ // 委托 Base() 构造函数
    		value2 = value;
    	}
    };
    void EntrustedConstruction()
    {
    	Base b(2);  //首先调用Base(int value) : Base() 毫无疑问
        //然后会走到base()中,先给value1复制,然后走到Base(int value) : Base() ,给value2赋值
    	std::cout << b.value1 << std::endl;
    	std::cout << b.value2 << std::endl;
    }
    

    运行结果:

    在这里插入图片描述

    注意事项

    1.不能出现”委托环“

    所谓 委托环(delegation cycle) 是指某类中有一个若多个委派构造函数, 然后在这些若干个的委派构造函数中, 某些目标构造函数可能同时是委派构造函数。 这样一来, 委派构造函数形成了一个链状结构(如链表的首尾相连情况.), 这就是所谓的“委托环”。

    2.构造函数不能同时“委派”和使用初始化列表

    参考链接

    聊一聊,什么是C++11新特性之“委托构造函数”

    展开全文
  • 委托构造函数&&继承构造函数委托构造函数适用场景注意继承构造函数使用场景 委托构造函数 允许同一个类中一个构造函数调用另一个构造函数,作用:简化变量的初始化。 适用场景 class class_c { public: ...

    委托构造函数

    允许同一个类中一个构造函数调用另一个构造函数,作用:简化变量的初始化。

    适用场景

    class class_c {
     publicint max_;
       int min_;
       int middle_;
    
       class_c() {}
       class_c(int max) {
         max_ = max > 0 ? max : 10;
       }
       class_c(int max, int min) {
         max_ = max > 0 ? max : 10;
         min_ = (min > 0 && min < max_) ? min : 1;
       }
       class_c(int max, int min, int middle) {
        //...
       }
    }
    

    大致是这个意思,上述这种操作可以但没必要–>改用委托构造函数:

    class class_c {
     public:
      int max_;
      int min_;
      int middle_;
    
      class_c(int max) {
        max_ = max > 0 ? max : 10;
      }
      class_c(int max, int min) : class_c(max) {
        min_ = (min > 0 && min < max_) ? min : 1;
      }
      class_c(int max, int min, int middle) : class_c(max, min) {
        middle_ = ...
      }
    }
    

    注意

    上述适用委托构造函数中class_c(int max, int min, int middle)的调用顺序:class_c(int max, int min, int middle) -> class_c(int max, int min) -> class_c(int max) 那这种链式调用的方式就不允许成环。
    另外,委托构造函数不能和类成员初始化同时出现(只能用成员赋值来实现)

    class class_c{
     public:
      class_c() {}
      class_c(string str) : string_(string) {}
      class_c(string str, int num) : class_c(str), num_(num) {}  // 不允许这么操作
      class_c(string str, int num) : class_c(str) {
        num_ = num;  //可以
      }
    }
    

    继承构造函数

    即子类直接使用父类的构造函数,

    使用场景

    class base{
      int x;
      double y;
      string s;
      base(int i) : x(i), y(0) {}
      base(int i, double j) : x(i), y(j){}
      base(int i, double j, const string& str) : x(i), y(j), s(str){}
    }
    //正确用法
    class derive : pubilc base {
      derive(int i) : base(i) {}
      derive(int i, double j) : base(i, j) {}
      ...
    } 
    
    //但是不能什么都不说就直接用,这样的写法就很不礼貌
    class derive : public base {
    }
    ...
    //使用
    derive d(1, 2.5);  //如果是那种不礼貌的写法,这里直接会编译报错
    

    原因是c++子类会隐藏父类的同名函数(除非你显示的说明,否则确实不应该调的到,符合design原则,emmm把公屏打在合理上!!!)

    继承构造函数的写法:

    class derive : public base {
      using base::base;
    }
    

    这种方式适用于使用父类的同名函数,当然就构造函数而言,这种方式不会去初始化子类新定义的成员变量(合理)


    展开全文
  • 委托构造函数 由来 构造函数多了以后,几乎必然的会出现代码重复的情况,为了避免这种情况,往往需要另外编写一个初始化函数,比如下面的Rect类 数据成员初始化之后要进行其他的工作,而这些工作又是每种构造方式都...

    委托构造函数

    由来

    构造函数多了以后,几乎必然的会出现代码重复的情况,为了避免这种情况,往往需要另外编写一个初始化函数,比如下面的Rect类

    在这里插入图片描述
    数据成员初始化之后要进行其他的工作,而这些工作又是每种构造方式都必须的,所以另外准备了一个init函数供各个构造函数调用。

    这种方式缺失必须了代码重复,但是有两个问题

    • 没有办法不重复的使用成员初始化列表
    • 必须编写另外一个初始化函数

    在C++11中,提出了一种新的解决方案:委托构造函数

    C++11的解决方案

    C++11扩展了构造函数的功能,增加了委托构造函数的概念,使得一个构造函数可以委托其他构造函数完成动作。使用委托构造函数之后,前面的代码变成了下面这样

    在这里插入图片描述
    真正的构造工作由最后一个构造函数完成,而其他的构造函数都是委托最后一个构造函数完成各自的构造工作。这种即去掉了重复代码又避免了前一种方法带来的问题

    通过代码可以看出:委托构造函数的语法和构造函数中调用基类构造函数一样。调用顺序,效果什么也差不多

    定义

    • 如果类自身的名字在初始化器列表中作为类或者标识符出现,则该列表必须仅由这一个成员初始化器组成,这种构造函数称为委托构造函数
      • 为了区分被调用者和调用者,称为初始化列表中调用“基准版本”的构造函数叫做委托构造函数,而被调用的“基础版本”叫做目标构造函数
      • 此情况下,首先由重载决议选择目标构造函数并给予执行,然后控制返回到委托构造函数并执行其函数体
      • 所谓委派构造,就是指委派函数将构造的任务委派给类模板构造函数来完成这样一种类构造的方式。
      • 上面仅由的意思,是指我们不能同时使用初始化列表和委托函数。
      • 在C++中,目标构造函数总是先于委托构造函数完成的。我们需要避免模板构造函数和委托构造函数中初始化同样的成员,否则很容器出错
    struct Rule1{
    	int i;
    	Rule1(int a) : i(a){}
    	Rule1() :Rule(40), i(1) {} // 无法通过编译
    };
    
    • 委托构造函数不能递归
    class Foo {
    public: 
      Foo(char x, int y) {}
      Foo(int y) : Foo('a', y) {} // Foo(int) 委托到 Foo(char,int)
    };
    

    委托构造函数的一个很实际的应用是使用构造函数模板产生模板构造函数,如下:

    #include <list>
    #include <vector>
    #include <deque>
    
    using namespace std;
    
    class TDConstructed{
        template<class T> TDConstructed(T first, T last) :
        l(first, last){}
        list<int> l;
    
    public:
        TDConstructed(vector<short> & v) :
                TDConstructed(v.begin(), v.end()){}
        TDConstructed(deque<int> & d) :
                TDConstructed(d.begin(), d.end()){}
    };
    

    此外,在异常处理方面,如果在委托构造函数中使用try的话,那么从目标构造函数中产生的异常,都可以在委托构造函数中被捕捉到。看个例子:

    using namespace std;
    
    class DCExcept{
    public:
        DCExcept(double d) try :DCExcept(1, d){
            printf("run the body\n");
            // ...其他初始化
        }catch(...){
            printf("caught exception\n");
        }
    private:
        DCExcept(int i, double d){
            printf("going to throw!\n");
            throw 0;
        }
        int type;
        double data;
    };
    int main(){
        DCExcept a(1.2);
    }
    

    在这里插入图片描述
    从上面可以看出,如果目标构造函数抛出异常,委托构造函数剩下的部分不会被执行

    展开全文
  • 1. 委托构造函数的使用场景 在实际的开发中,为了满足不同用户的不同需求,我们的一个类可能会有很多构造函数的重载版本,特别的,这些重载版本的工作内容有的比较复杂,有的比较简单,并且他们之间会有一些交叉重复...
  • C++委托构造函数

    千次阅读 2018-02-20 22:20:11
    在c++11中有一个新特性,就是委托构造函数委托构造函数可以使用当前类的其他构造函数来帮助当前构造函数初始化。换而言之,就是可以将当前构造函数的部分(或者全部)职责交给本类的另一个构造函数。 我们先看看...
  • 委托构造函数

    2021-01-20 12:08:29
    C++11新标准,委托构造函数是为了构造函数减少代码的重复, 经过看过的文章简单粗暴地总结,委托构造函数在类内创建和实现。 #include<iostream> using namespace std; class Clock{ public: //定义构造函数...
  • 委托构造函数属于c++11新标准,因此文中涉及到程序在编译时需要指定编译器类型为c++11,linux可以通过-std=c++11选项指定: g++ test.cpp -std=c++11 -o test 1、何为委托构造函数 顾名思义,委托构造函数使用它所属...
  • C++11 委托构造函数

    2018-01-18 19:22:58
    C++ 11 新特性 委托构造函数
  • (一)构造函数允许使用构造函数初始值列表,来为变量初始化 适用于成员变量有构造函数的任何情况 代码示例: #include using namespace std; class Date { public: //构造函数初始化列表 Date(int y, int m, ...
  •  如果基类的构造函数很多,那么子类的构造函数想要实现同样多的构造接口必须一一调用基类的构造函数,于是C++11 引入继承构造函数。 class _A { public: _A( int _InInt ) {;} _A( double _InDouble, int _In...
  • 一、先执行静态成员的构造函数,如果静态成员只是在类定义中声明了,而没有实现,是不用构造的。必须初始化后才执行其构造函数。 二、任何抽象基类的构造函数按照它们被继承的顺序构造(不是初始化列表中的顺序) 三...
  • 委托构造函数 什么是委托构造函数委托构造函数是由C++11引入的新概念,是对C++构造函数的改进,允许构造函数使用初始化列表调用同类中的其他构造函数,旨在简化构造函数的书写,提升代码的可维护性,降低代码的...
  • 在一个构造函数的定义中,以成员初始化列表的方式使用另一个构造函数,这被称为委托。 可以避免重复编写多个重复构造函数中相同的代码,让编码工作更简单、更可靠。 class Notes{ int k; double x; string ...
  • 委托构造函数是同一个类中不同构造函数之间的复用 继承构造函数是派生类对父类构造函数的复用 表示方式 //委托函数优化,优化冗余代码 class Base1{ public: Base1(){} Base1(int max1){ this->bmax = max1 &...
  • 关于使用C++11中委托构造函数

    千次阅读 多人点赞 2017-06-29 11:18:01
    今天在读《C++Primer》时读到委托构造函数一节,书中关于委托构造函数是这样描述的: 一个委托构造函数使用它所属的类的其他构造函数执行自己的初始化过程,或者说它把自己的一些(或者全部)职责委托给了其他构造...
  • 构造函数 一、构造函数的作用 1.在对象被创建时使用特定的值构造对象,将对象初始化为一个特定的初始状态。 2 例如: 希望在构造一个Clock类对象时,将初试时间设为0:0:0,就可以通过构造函数来设置。 二、构造...
  • 委托构造函数2.3.4. 1. 委托构造函数      委托构造函数(delegating constructor) 是C++11中新引入的一个新特性. 它是对C++98版本中的构造函数的一个改进. 所谓"委托构造函数", 就是使用它所归属类的其他构造...
  • class cook { public: cook( char* rice, char* vegetable ); //洗菜,淘米 cook( char* rice);... 洗菜是两个构造函数共有的, 定义两边会很麻烦, 那么怎么办呢class cook { public: ...
  • 委托构造函数(C++)

    2021-04-25 10:48:35
    所谓委托构造函数即是使用它所属的类的其他构造函数执行它自己的初始化过程,或者说它将自己初始化的工作委托给了其他构造函数。 其形式是将构造函数初始化时的初始值列表替换为调用其委托的构造函数。例如: class ...
  • C++11 继承构造函数与委托构造函数

    千次阅读 2020-02-29 17:36:43
    如果基类的构造函数很多,那么子类的构造函数想要实现同样多的构造接口必须一一调用基类的构造函数,于是C++11 引入继承构造函数。 class _A { public: _A(int _InInt) { ; } _A(double _InDouble, int _InInt) { ...
  • C++委托构造函数实例

    2019-11-03 19:07:15
    C++委托构造函数的实例 #include<iostream> using namespace std; class Date { public: //非委托构造函数使用对应的实参初始化成员 Date(int year,int month,int day):_year(year), _month...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,690
精华内容 29,076
关键字:

委托构造函数

友情链接: vodafone.rar