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

    千次阅读 2019-09-26 14:16:01
    如果希望对不同的对象赋予不同的初始值,则需要使用带参数构造函数,在调用不同对象的构造函数时,将不同的数据构造函数,以实现不同的初始化。 构造函数首部的一般格式为: 构造函数名(类型1 形参1, 类型2 ...

    不带参数的构造函数使该类的每一个对象都得到相同的初始值。
    如果希望对不同的对象赋予不同的初始值,则需要使用带参数的构造函数,在调用不同对象的构造函数时,将不同的数据传给构造函数,以实现不同的初始化。
     
    构造函数首部的一般格式为:
        构造函数名(类型1  形参1, 类型2  形参2, …)
    由于用户是不能调用构造函数的,因此无法采用常规的调用函数的方法给出实参。实参是在创建对象时给出的。创建对象的一般格式为:
        类名  对象名(实参1, 实参2, …);

    include <iostream>
    using namespace std;
    class Box
    {
       public :
       Box(int,int,int);
       int volume( );
       private :
       int height;
       int width;
       int length;
    };
    //声明带参数的构造函数//声明计算体积的函数
    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(12,25,30); //建立对象box1,并指定box1长、宽、高的值
       cout<<"The volume of box1 is "<<box1.volume( )<<endl;
       Box box2(15,30,21); //建立对象box2,并指定box2长、宽、高的值
       cout<<"The volume of box2 is "<<box2.volume( )<<endl;
       return 0;
    }

     

    展开全文
  • 关于构造函数传递参数的理解

    千次阅读 2017-03-02 11:18:34
    如果一个类写了有参数构造方法,默认无参数构造方法将不存在,一个类可以有多个构造方法, 但是创建对象只能使用一个构造方法,具体看创建对象的参数而定。创建对象时,自动调用一个构造方法,因此可以将常用的...
    一、什么是构造方法?
    
        构造方法是一个方法名和类名一致、没有返回值的方法。一个类中没有写构造方法,其默认为无参数的构造方法。
    在创建类对象后,自动调用该方法。如果一个类写了有参数的构造方法,默认无参数的构造方法将不存在,一个类可以有多个构造方法,
    但是创建对象只能使用一个构造方法,具体看创建对象的参数而定。创建对象时,自动调用一个构造方法,因此可以将常用的属性放入构造方法中定义。


    二、构造方法传递常用对象有8大基本数据类型、和引用类型。在此谈谈传递引用类型参数的理解。
        1、类 类型:在定义一个类A时,创建类A的带有类类型参数的构造方法,在类B中实例化类A,传递类B的引用。例如:  A aa = new A(this);
                


        2、数组类型:将数组看做一个对象,如定义一个类A,在使用该数组的类B定义A类型的数组。例如: A[] aa = new A[];
                 此时要类C要用到该数组,在类C中创建带数组类型参数的构造方法,在类B中实例化类C,传递该数组。例如:C cc = new C(aa);


        结论:用构造方法传递参数时,参数将从调用对象的类传到带参数构造方法的类。例如:A aa = new A(this);把参数传到A类中使用。
     
    展开全文
  • c++ 单例模式--构造函数传递参数

    千次阅读 2018-08-10 15:34:32
    c++ 单例模式–构造函数传递参数 class Singleton: { public: static Singleton * GetInstance(MineStrut* pMineStruct) { if (m_pInstance == NULL) { m_pInstance = new Singleton(pMineStruct);...

    c++ 单例模式–构造函数传递参数

    // singleton.h
    
    class Singleton: 
    { 
    public: 
        static Singleton * GetInstance(MineStrut* pMineStruct) 
        { 
            if (m_pInstance == NULL) {
            m_pInstance = new Singleton(pMineStruct); 
        }
            return m_pInstance; 
        } 
    
    private: 
        Singleton(MineStrut* pMineStruct)
        : m_pMineStruct(m_pMineStruct)
        {
        }
    
    private:    
        MineStrut* m_pMineStruct;
        static Singleton * m_pInstance; 
    };
    //singleton.cc
    Singleton *Singleton::m_pInstance = nullptr;
    void Singleton::function() {}
    ....

    class中static Singleton *m_pInstance为申明,需要在singleton.cc中定义它,不然会出现以下错误。
    test.cpp:(.text._ZN3Log11getInstanceEmj[_ZN3Log11getInstanceEmj]+0x45): undefined reference to `Singleton::m_pInstance’

    展开全文
  • 但是如果我问你“拷贝构造函数参数为什么必须使用引用类型?”这个问题, 你会怎么回答? 或许你会回答为了减少一次内存拷贝? 很惭愧的是,我的第一感觉也是这么回答。不过还好,我思索一下以后,发现这个答案是...

       在C++中, 构造函数,拷贝构造函数,析构函数和赋值函数(赋值运算符重载)是最基本不过的需要掌握的知识。 但是如果我问你“拷贝构造函数的参数为什么必须使用引用类型?”这个问题, 你会怎么回答? 或许你会回答为了减少一次内存拷贝? 很惭愧的是,我的第一感觉也是这么回答。不过还好,我思索一下以后,发现这个答案是不对的。

    原因:
           如果拷贝构造函数中的参数不是一个引用,即形如CClass(const CClass c_class),那么就相当于采用了传值的方式(pass-by-value),而传值的方式会调用该类的拷贝构造函数,从而造成无穷递归地调用拷贝构造函数。因此拷贝构造函数的参数必须是一个引用。
           需要澄清的是,传指针其实也是传值,如果上面的拷贝构造函数写成CClass(const CClass* c_class),也是不行的。事实上,只有传引用不是传值外,其他所有的传递方式都是传值。

           先从一个小例子开始:(自己测试一下自己看看这个程序的输出是什么?)

    
    #include<iostream>
    using namespace std;
     
    class CExample
    {
    private:
        int m_nTest;
     
    public:
        CExample(int x) : m_nTest(x)      //带参数构造函数
        { 
            cout << "constructor with argument"<<endl;
        }
     
        // 拷贝构造函数,参数中的const不是严格必须的,但引用符号是必须的
        CExample(const CExample & ex)     //拷贝构造函数
        {
            m_nTest = ex.m_nTest;
            cout << "copy constructor"<<endl;
        }
     
        CExample& operator = (const CExample &ex)   //赋值函数(赋值运算符重载)
        {    
            cout << "assignment operator"<<endl;
            m_nTest = ex.m_nTest;
            return *this;
        }
     
        void myTestFunc(CExample ex)
        {
        }
    };
     
    int main(void)
    {
        CExample aaa(2);
        CExample bbb(3);
        bbb = aaa;
        CExample ccc = aaa;
        bbb.myTestFunc(aaa);
     
        return 0;    
    }


    这个例子的输出结果是:
    constructor with argument        // CExample aaa(2);
    constructor with argument        // CExample bbb(3);
    assignment operator              // bbb = aaa;
    copy constructor                 // CExample ccc = aaa;
    copy constructor                 //  bbb.myTestFunc(aaa);
    如果你能一眼看出就是这个结果的话, 恭喜你,可以站起来扭扭屁股,不用再往下看了。

    如果你的结果和输出结果有误差, 那拜托你谦虚的看完。

    第一个输出: constructor with argument      // CExample aaa(2);

    如果你不理解的话, 找个人把你拖出去痛打一顿,然后嘴里还喊着“我是二师兄,我是二师兄.......”

    第二个输出:constructor with argument     // CExample bbb(3);

    分析同第一个

    第三个输出: assignment operator                // bbb = aaa;

    第四个输出: copy constructor                      // CExample ccc = aaa;

    这两个得放到一块说。 肯定会有人问为什么两个不一致。原因是, bbb对象已经实例化了,不需要构造,此时只是将aaa赋值给bbb,只会调用赋值函数,就这么简单,还不懂的话,撞墙去! 但是ccc还没有实例化,因此调用的是拷贝构造函数,构造出ccc,而不是赋值函数,还不懂的话,我撞墙去!!

     

    第五个输出: copy constructor                      //  bbb.myTestFunc(aaa);

    实际上是aaa作为参数传递给bbb.myTestFunc(CExample ex), 即CExample ex = aaa;和第四个一致的, 所以还是拷贝构造函数,而不是赋值函数, 如果仍然不懂, 我的头刚才已经流血了,不要再让我撞了,你就自己使劲的再装一次吧。

    通过这个例子, 我们来分析一下为什么拷贝构造函数的参数只能使用引用类型。

    看第四个输出: copy constructor                      // CExample ccc = aaa;

    构造ccc,实质上是ccc.CExample(aaa); 我们假如拷贝构造函数参数不是引用类型的话, 那么将使得 ccc.CExample(aaa)变成aaa传值给ccc.CExample(CExample ex),即CExample ex = aaa,因为 ex 没有被初始化, 所以 CExample ex = aaa 继续调用拷贝构造函数,接下来的是构造ex,也就是 ex.CExample(aaa),必然又会有aaa传给CExample(CExample ex), 即 CExample ex = aaa;那么又会触发拷贝构造函数,就这下永远的递归下去。

    所以绕了那么大的弯子,就是想说明拷贝构造函数的参数使用引用类型不是为了减少一次内存拷贝, 而是避免拷贝构造函数无限制的递归下去。


    附带说明,在下面几种情况下会调用拷贝构造函数:
    a、   显式或隐式地用同类型的一个对象来初始化另外一个对象。如上例中,用对象c初始化d;
    b、  作为实参(argument)传递给一个函数。如CClass(const CClass c_class)中,就会调用CClass的拷贝构造函数;
    c、  在函数体内返回一个对象时,也会调用返回值类型的拷贝构造函数;
    d、  初始化序列容器中的元素时。比如 vector<string> svec(5),string的缺省构造函数和拷贝构造函数都会被调用;
    e、  用列表的方式初始化数组元素时。string a[] = {string(“hello”), string(“world”)}; 会调用string的拷贝构造函数。
    如果在没有显式声明构造函数的情况下,编译器都会为一个类合成一个缺省的构造函数。如果在一个类中声明了一个构造函数,那么就会阻止编译器为该类合成缺省的构造函数。和构造函数不同的是,即便定义了其他构造函数(但没有定义拷贝构造函数),编译器总是会为我们合成一个拷贝构造函数。
    另外函数的返回值是不是引用也有很大的区别,返回的不是引用的时候,只是一个简单的对象,此时需要调用拷贝构造函数,否则,如果是引用的话就不需要调用拷贝构造函数。

    #include<iostream>
    using namespace std;
     
    class A
    {
    private:
        int m_nTest;
    public:
        A()
        {
        }
        A(const A& other)    //构造函数重载
        {
            m_nTest = other.m_nTest;
            cout << "copy constructor"<<endl;  
        }
        A & operator =(const A& other)
        {
            if(this != &other)
            {
                m_nTest = other.m_nTest;
                cout<<"Copy Assign"<<endl;
            }
            return *this;
        }
    };
     
    A fun(A &x)
    {
        return x;     //返回的不是引用的时候,需要调用拷贝构造函数
    }
     
    int main(void)
    {
        A test;
        fun(test);
        system("pause");
        return 0;
    }


    分享一道笔试题目,编译运行下图中的C++代码,结果是什么?(A)编译错误;(B)编译成功,运行时程序崩溃;(C)编译运行正常,输出10。请选择正确答案并分析原因。

    class A
    {
    private:
        int value;
    public:
        A(int n)
        {
            value = n;
        }
     
        A(A other)
        {
            value = other.value;
        }
        void Print()
        {
            cout<<value<<endl;
        }
    };
     
    int main(void)
    {
        A a = 10;
        A b = a;
        b.Print();
        return 0;
    }


    答案:编译错误。在复制构造函数中传入的参数是A的一个实例。由于是传值,把形参拷贝到实参会调用复制构造函数。因此如果允许复制构造函数传值,那么会形成永无休止的递归并造成栈溢出。因此C++的标准不允许复制构造函数传值参数,而必须是传引用或者常量引用。在Visual Studio和GCC中,都将编译出错。

    --------------------- 
    作者:hackbuteer1 
    来源:CSDN 
    原文:https://blog.csdn.net/Hackbuteer1/article/details/6545882 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • C++中构造函数默认参数使用

    千次阅读 2019-05-01 15:48:54
    一代码 #include <iostream> using namespace std; class Box{ public: ...//在声明构造函数时指定默认参数 int volume(); private: int height,width,length; }; Box::Box(int h,int...
  • 附图: @Autowired 要放在前面传递变量过来的类中
  • 这篇文章主要介绍了使用Springboot注入带参数构造函数实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧 我们使用@Service注解一个service,默认注入的是不带参的构造函数,如果我们需要...
  • 构造函数、析构函数是怎么回...下面定义的变量需要通过构造函数Line中的参数进行初始化,当用Line创建一个类对象时自动执行。 class Line { public: Line(double len); // 这是构造函数声明 void getLength(); ...
  • 如果用户没有自行编写构造函数,则 C++ 自动提供一个无参数构造函数,称为默认构造函数。这个默认构造函数不做任何初始化工作。一旦用户编写了构造函数,则这个无参数的默认构造函数就消失了。如果用户还希望能有...
  • 1. 构造函数参数依赖的例子 @Component public class BeanA { // 省略实现 // ... } @Component public class BeanB { BeanA a; // 注意,这里可以不使用 @AutoWired 等注解就会导致Spring的依赖注入 ...
  • 构造函数传递参数

    千次阅读 2016-10-26 22:03:05
    构造函数传递参数
  • C++类构造函数初始化列表 构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表,每个数据成员后面跟一个放在括号中的初始化式。例如: class CExample { public:  int a;  float ...
  • C++构造函数中用参数列表初始化成员

    万次阅读 多人点赞 2015-09-29 14:57:54
    C++构造函数中初始化成员参数列表初始化成员(必须用的原因:对象成员的初始化,const修饰的成员的初始化,引用成员的初始化,子类调用父类的构造函数初始化父类成员)参数列表在构造函数执行之前执行,参数列表中执行...
  • ActivityA有构造函数 public ActivityA(Object obj)//ActivityA继承父类 { super(obj) } 我想在ActivityB中跳转到ActivityA 但是问题是要怎么跳ActivityA才能执行上方的构造函数呢?因为它会默认的执行默认无参的...
  • #include &...class CExample{public: CExample(int x) :m_nTest(x) //带参数构造函数 { cout&lt;&lt; "constructor with argument."&lt;&lt;endl; } CExample(const C...
  • 现在有一个需求是: 有一个类它没有默认的构造函数, 类似下面这种情况: public class Person(){ String name; int age; public Person(String name, int age) { this.name = name; this.age= age; } } 获得...
  • 系统会主动的通过用户在构造函数中设定的默认值进行数据成员初始化,一般情况下如果用户没有对数据成员初始化,没有显现的定义构造函数,系统会默认的调用空的构造函数,这个构造函数也不具体做什么,也没有参数,不...
  • 在C++中,程序员希望对不同的对象赋予不同的初值,可以采用带参数构造函数,在调用不同对象的构造函数时,从外面将不同的数据传递给构造函数, 以实现不同的初始化。 C++构造函数首部的一般形式为 构造函数名...
  • 关于构造函数参数传递

    千次阅读 2010-03-07 09:52:00
    如果没有从派生类的构造函数初始化列表中显示调用,参数是不会给父类的。#include "stdafx.h"class A{protected: int m_data;public: A(int data = 0) { m_data = data; }};class B : public A{protected: int m_...
  • 向基类构造函数传递参数

    千次阅读 2014-03-26 10:02:09
    原因也不难理解,因为子类将基类的所有成员都继承了过去,所以被继承的成员也会出现在子类里,那么我们在构造一个子类的对象时,就会难免调用基类的构造函数。 在创建派生类的构造函数时,有两种方法可以对数据进行...
  • 1.标准构造函数,可选参数,默认参数,初始化列表,命名构造函数,工厂构造函数,命名工厂构造函数,get,set,静态方法,抽象方法,抽象类 //所有的类都继承自Object class Person { String name; int age; Person(this....
  • 可以看到,在带参数构造函数里打印出来的对象地址 和对象obj的地址不一致。 实际上 代码13行的调用只是在栈上生成了一个临时对象 对于自己本身毫无影响 还可以发现 构造函数的互相调用引起的后果不是死循环 而是栈...
  • 1 常数据成员只能通过构造函数初始化表对其进行初始化  常数据成员只能通过构造函数初始化表对其进行初始化,任何其它函数都不能对常数据成员赋值。如类体中定义了常数据成员hour: constint hour;//定义hour为常...
  • 众所周知,java没有办法设置默认参数,只有通过函数的重载的性质来完成对默认参数的设置。 例如: 为了是的函数能最大形式的通用,会传入正则表达式,但在大部分情况下,使用默认的参数就够了,所以就对removeSpace...
  • 利用构造函数传参;(layabox)ts

    千次阅读 2018-06-28 09:27:57
    当你在一个类里面想要调用其他函数传入的参数的时候,比如你在游戏进程中;我想当我出完牌;...这时候你就可以利用构造函数传入参数;什么是构造函数: 构造函数就是一个类默认的属性;比如 你...
  • Qt 带自定义参数构造函数

    万次阅读 2012-09-27 17:14:26
    Qt中带自定义的构造函数事实上和C++的构造函数一样,但又有些不同。 例如: class DataTerminal : public QMainWindow {  Q_OBJECT public:  explicit DataTerminal(QString username,QWidget *parent = 0...
  • 有默认参数构造函数构造函数参数的值既可以通过实参传递,也可以指定为某些默认值,即如果用户不指定实参值,编译系统就使形参的值为默认值。 一般来说在类中声明构造函数的时候,给那些带有形参的变量直接...
  • JS构造函数创建对象时的传参问题

    千次阅读 2017-03-09 20:35:15
    所以如果要通过构造函数传参创建一个属性值为对象的对象,可以在构造函数定义好属性值为对象的属性,可以如下 function User(obj){ this .loginInfos = {} ; this .loginInfos .name = obj .loginInfos ....
  • 关于c++中不允许复制构造函数传值参数的理解

    千次阅读 多人点赞 2017-04-12 17:27:23
    如果拷贝构造函数是传值而不是引用,当调用ccc.CExample(aaa)时,aaa作为参数传值给ccc.CExample(CExample ex),即CExample ex = aaa,因为ex没有被初始化,所以会继续调用拷贝构造函数,接下来是构造ex,也就是ex...
  • #include "stdafx.h" #include #include #include using namespace std; class animal { public: animal(int height, int weight) { cout } }; class fish :public animal ...fi

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,160,072
精华内容 464,028
关键字:

构造函数传参数