精华内容
下载资源
问答
  • C++ 中调用构造函数有返回值吗?

    千次阅读 2019-04-10 10:00:20
    C++中的构造函数: 最近在面试中问道一个问题,C++中构造函数有返回值吗? 例如 class A { public: ...如果构造函数有返回值比如下:有返回值且返回值为int类型; //若构造函数有参数 int A():x_...

    C++中的构造函数:

    最近在面试中问道一个问题,C++中构造函数有返回值吗?

    例如

    class A
    {
    public: 
    	A():x(1){}
    	A(int i):x(i){}
    private:
    	int x;
    }
    

    官方解释在C++标准规定了构造/析构/自定义类型转换符不可以指定返回类型。

    如果构造函数有返回值比如下:有返回值且返回值为int类型;

    //若构造函数有参数
     int A():x_(0) { return 1; //1表示构造成功,0表示失败}
    
    //此时如果这样定义一个临时对象:
    
    A a = A(); //那么此时的 a.x等于多少??
    

    因为 A()调用的是无参构造函数,此时无参构造函数调用成功,返回值为1,此时 x 赋初值为 0,并将1赋值初始化给A a, 及又会调用有参构造函数 A(int i) , 那么 a.x有变成了1,就产生了语法歧义;
    构造函数的调用之所以不设返回值,是因为构造函数的特殊性决定的。从基本语义角度来讲,构造函数返回的应当是所构造的对象。否则,我们将无法使用临时对象:

    展开全文
  • C#的泛型的类型参数可以带参数的构造函数的约束方式吗? 原文:C#的泛型的类型参数可以带参数的构造函数的约束方式吗?Review后看到标题让我十分羞愧自己语文功底太差,估计...请见谅......我还...
    原文:C#的泛型的类型参数可以有带参数的构造函数的约束方式吗?

    Review后看到标题让我十分羞愧自己语文功底太差,估计...请见谅......我还特地把这句写回开头了......

     

     

    问题

    前天遇到的一个问题,所以在MSDN发了个问,刚也丰富了下问题,关于泛型的。

    最近用EF尝试DDD常常有些奇怪的想法,比如“EF的Model First能否添加泛型支持”。这次是“泛型的类型能否有带参数的约束方式”。

    具体想法很简单,在我使用泛型的时候,我发现我需要实例化一个类型参数:

    1 class MyClass<T>
    2 {
    3     public MyClass1()
    4     {
    5         this.MyObject = new T();
    6     }
    7 
    8     T MyObject { get; set; }
    9 }

    当然,上面会报错

    错误内容是T没有一个new约束(new constraint),查阅下MSDN,得到了泛型的类型参数的new约束的内容

    所以接下来正确的代码就是:

     1 class MyClass<T>
     2     where T : new()
     3 {
     4     public MyClass1()
     5     {
     6         this.MyObject = new T();
     7     }
     8 
     9     T MyObject { get; set; }
    10 }

     

    然后,后来我发现,我需要根据参数来创建新的对象,而且该方法在泛型的构造函数中实现最合适,所以我希望有这样的代码:

     1 class MyClass1<T>
     2     where T : new(string)
     3 {
     4     public MyClass(string request)
     5     {
     6         this.MyObject = new T(request);
     7     }
     8 
     9     T MyObject { get; set; }
    10 }

    可惜这下就错大了,然后查阅泛型的约束方式列表,发现根本没有带参数的构造函数这种约束

     

    所以就发生了我上面在MSDN上问的那个问题,寻求一个“优雅的解决方案”。

     

    一般解决方案就像问题中的回答那样有两种,也是我试过但是很不爽的两种,我们依次看看。

    补充:

    • James.Ying提醒,还有从构造函数传入
    • 由@Choo提醒,用Activator.CreateInstance

     

     

    工厂模式

    首先是Factory Pattern,就是建一个工厂类,先看看代码,这是其中一种写法,请不要纠结在Factory Pattern上:

     1 class MyClass<T, TFactory>
     2     where TFactory : IFactory<T>, new()
     3 {
     4     public MyClass(string request)
     5     {
     6         var factory = new TFactory();
     7 
     8         this.MyObject = factory.New(request);
     9     }
    10 
    11     T MyObject { get; set; }
    12 }
    13 
    14 interface IFactory<T>
    15 {
    16     T New(string request);
    17 }

    实现中你会发现,这样需要为每个派生类或者实例类别创建并维护一个Factory类,那样泛型本身就没那么大意义了,本来就是为了减少类型重用逻辑而采用泛型的

     

     

    抽象基类的静态抽象方法

    如果不想维护多一个类,那么就在目标类本身下手,所以我们可以为目标类创建一个基类:

     1 class MyClass<T>
     2     where T : TBase, new()
     3 {
     4     public MyClass(string request)
     5     {
     6         this.MyObject = T.New(request);
     7     }
     8 
     9     T MyObject { get; set; }
    10 }
    11 
    12 abstract class TBase
    13 {
    14     public abstract static TBase New(string request);
    15 }

    为了防止误人子弟,首先要说在前头的是,这样写是会编译错误的!

    约束上是没错的,但是它报的错误是类似于“T是个类型参数,不能这么用!”('T' is a 'type parameter', which is not valid in the given context)。

     

     

    从构造函数传入

    还有一种基础的做法反而忘记了,由James.Ying提醒想起来,就是从泛型类的构造函数传入。

    class MyClass<T>
        where T : TBase, new()
    {
        public MyClass(T myObject)
        {
            this.MyObject = myObject;
        }
    
        T MyObject { get; set; }
    }

    这种方式使得泛型类简洁多了,把实例化的过程交给了调用者,有点依赖倒置了(其实凡是应该在泛型里实现的而交给了调用者或者继承者都是这样)。

    优点是泛型简单了,缺点就是你无法保证实例化使用的构造函数是T(string)。另外,它可能会降低代码的重用性。假设实例化是有条件地,而且所有派生类的逻辑是统一的,那么还是在泛型基类中实现比较好。

    简单情况下这是对泛型来说最优雅的方式了。

     

     

    Activator.CreateInstance

    该方法可以在http://msdn.microsoft.com/en-us/library/system.activator.createinstance(v=vs.110).aspx见到,说明就比较明确了:

    用最匹配的构造函数创建一个类型的实例(Creates an instance of the specified type using the constructor that best matches the specified parameters)。

    写法也很爽:

    class MyClass<T>
    {
        public MyClass(string request)
        {
            this.MyObject = (T)Activator.CreateInstance(typeof(T), request);
        }
    
        T MyObject { get; set; }
    }

    这种方法做得到,也很简短,也不用多做接口和基类。

    缺点就是没有约束,没办法保证T能有带指定数量和类型参数的构造函数,或者是否有构造函数。

    如果T不符合设计需求的话会报相应的异常

     

     

    原来泛型的类型参数是这么设计的

    至此,便可以知道,C#的泛型里,类型参数是一种“非类”的存在,类型参数的约束(Constraints on Type Parameters)仅仅是用来描述具体的类在实例化或者继承时所需要达到的条件。而在泛型内部,类型参数仅仅是一种“特别的存在”,它用来描述类,但却无法用作类。

     

     

    那么,类型参数可以有......参考本文题目......

    首先,其实这个问题本身就是泛型的类型参数能否有带参数的实例化方式,比如 T myObject = new T("Hello World!“) 。

    然后,由于类型参数是用“约束”的方式来进行实例类的特点的描述的,所以,问题才变成了泛型的类型参数能否有带参数的构造函数的约束方式,比如 where T : new(string) 。

    要做假设的话,起始就是个证伪的问题,要证明它存在是否会造成什么原则问题。

    首先能对比的就是泛型的类型参数已经有了不带参数的构造函数的约束方式了,那么泛型的类型参数就算有带了参数的构造函数的约束方式又如何?至少,泛型的类型参数已经有了不带参数的构造函数的约束方式证明了泛型的类型参数有构造函数的约束方式并不会造成什么问题而且技术上是可以实现的。(......)

    在我们实例化一个新对象的时候通常会用两种初始化方式:

    • 利用构造函数传参
    • 实例化后赋值

    大部分情况下两种方式产生的结果是差不多的,这种大部分情况是指一般所涉及到的属性或参数都是公开的(public),本来就是开放读写的,所以内部写和外部写都差不多。

    但遇到一些情况,比如一些业务约束,需要对参数进行处理或者利用参数进行操作,最终操作结果是私密的(private),那么就会偏向于选用构造函数传参。或者会使用一个特殊的方法,由该方法在类实例化之后再把需要的数据带进来进行操作,这么做些许有失“一气呵成”的爽快。

    利用构造函数传参并不是什么容易替代的方式,因为它在绝大部分属于它的场景里都是最优的解决方案。有时候,初始化一个对象到使用,一气呵成是最好的,因为这个事务本身就有很强的原子性。一个对象的两种初始化方式造成了双入口的麻烦,作为该类的使用者,有时候你会模糊,两种方式所产生的结果你无法准确地把握;对于开发者,两种实现方式供的出现在规范上也要求要么二选一,要么保证两者一致。当类变得相对复杂的时候,事情就没那么简单了。

    所以,我们确实会需要泛型的类型参数有带了参数的构造函数的约束方式的一些场景。它虽然不是必要的,但是绝对是一种需要,就像get/set访问器那样。

     

     

    补充地说,其实更大的命题是类型参数是否可以当作类使用

    假设它可以由带参数的构造函数约束了,那么可不可以直接如约束那样当作类来使用呢?比如调用静态方法?在泛型中创建继承于该类型参数的类?

    如此种种算来发现每一种都有可能是特例,而不是一个简单的实现即可解决的。

    比如调用静态方法来说,T.Hello()所涉及的就是执行的时候T能明确是哪个类;而在泛型类中创建继承于该类型参数的类就会变得复杂。

    单单想想调用那个类的方法:MyClass<T>.MySubClass,这里的语法就有点“不一般”了,未必是一个“仅仅是泛型本身的问题”。

    逼格高一点地说,越来越多的功能对C#或者任何一门语言来说是一条正确的道路吗?

     

     

    关于题目

    如果你有不满,可以提供合适的标题,禁止以任何方式攻击作者!

     

     

     

     

    posted on 2019-08-01 23:38 NET未来之路 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/lonelyxmas/p/11286112.html

    展开全文
  • 在类中定义的info(char name[], char sex[], int age)称为构造方法,而下面的就称为构造函数,构造方法的名称和类名完全相同,并且其中完全没有声明其方法的类型,这里把我能糊涂了,在jiava中构造函数和构造方法是...
  • 只有存在隐式转换,U转为T才通过编译。 用成员函数模板生成“可接受所有兼容类型”的函数。...声明成员函数模板用于泛化copy构造函数,赋值操作时,还是要声明普通copy构造函数,赋值操作版本。 ...

    在这里插入图片描述
    在这里插入图片描述

    只有存在隐式转换,U*转为T*才通过编译。
    

    用成员函数模板生成“可接受所有兼容类型”的函数。如果想阻止隐式转换,就要写copy构造函数,赋值操作的explicit多态版本。
    声明成员函数模板用于泛化copy构造函数,赋值操作时,还是要声明普通copy构造函数,赋值操作版本。

    展开全文
  • 文章目录1. 类的6个默认成员函数2....构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都 一个合适的初始值,并且在对象的生命周期内只调用一次。 构造函数

    1. 类的6个默认成员函数

    如果一个类中什么成员都没有,简称为空类。空类中什么都没有吗?并不是的,任何一个类在我们不写的情况下,都会自动生成下面6个默认成员函数.
    在这里插入图片描述

    相关题目

    1、类的析构函数调用完全按照构造函数调用的相反顺序进行调用
    2、全局对象先于局部对象进行构造
    3、静态对象先于普通对象进行构造
    4、对象析构要在生存作用域结束的时候才进行析构,
    5、因为赋值符号=需要对象进行驱动,所以只能重载为成员函数

    2. 构造函数

    构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都有 一个合适的初始值,并且在对象的生命周期内只调用一次。

    构造函数特征

    1.函数名与类名相同。
    2.无返回值
    3.对象实例化时,编译器自动调用对应的构造函数
    4.构造函数可以重载

    class Date*/
    {
    public:
    
    	Date (int year, int month, int day)//带参的构造函数
    	{
    		cout << "Data(int year,int month,int day)"<< endl;
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	Date()//无参的构造函数
    	{
    		cout << "Data()" << endl;
    		_year = 2021;
    		_month = 3;
    		_day = 1;
    	}
    	void Print()
    	{
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	//想要的是,对象构造出来就初始化
    	//我们没写,编译器默认生成了构造函数,但是d1里面的值还是随机值。
    	//说明默认的构造在这里不行,需要我们自己写
    	Date d1(2021,2,2); //调用带参的构造函数
    	d1.Print();
    	Date d2;//也可以不传参数初始化
    	d2.Print();//给多个构造函数,有多种初始化方式
    
    	return 0;
    }
    
    //将带参和无参结合,得到一个全缺省的构造函数
    class Date
    {
    public:
    	Date(int year = 2021, int month = 3, int day = 1)//带参的构造函数
    	{
    		cout << "Data(int year,int month,int day)" << endl;
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	//Date()//无参的构造函数
    	//{
    	//	cout << "Data()" << endl;
    	//	_year = 2021;
    	//	_month = 3;
    	//	_day = 1;
    	//}
    	void Print()
    	{
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d1(2021, 2, 2); 
    	d1.Print();
    	Date d2;
    	d2.Print();
    
    	return 0;
    }
    

    C++把类型分成内置类型(基本类型)和自定义类型,内置类型如int/char…,自定义类型就是使用class/struct/union自己定义的类型。
    如下程序,编译器生成的构造函数会对自定类型成员_t调用它的默认成员函数。

    class Time
    {
    public:
    	Time()
    	{
    		cout << "Time()" << endl;
    		_hour = 0;
    		_minute = 0;
    		_second = 0;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    class Date
    {
    private:
    	// 基本类型(内置类型)
    	int _year;
    	int _month;
    	int _day;
    	// 自定义类型
    	Time _t;
    };
    int main()
    {
    	Date d;
    	return 0;
    }
    //不传参就可以调用的函数就是默认成员函数
    //无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函//数,都可以认为是默认成员函数。
    
    

    3. 析构函数

    析构函数:与构造函数功能相反,析构函数不是完成对象的销毁,局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数,完成类的一些资源清理工作。

    析构函数特征
    1. 析构函数名是在类名前加上字符 ~。
    2. 无参数无返回值。
    3. 一个类有且只有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。
    4. 对象生命周期结束时,C++编译系统系统自动调用析构函数。
    typedef int DataType;
    class SeqList
    {
    public:
    	SeqList(int capacity = 10)
    	{
    		_pData = (DataType*)malloc(capacity * sizeof(DataType));
    		assert(_pData);
    		_size = 0;
    		_capacity = capacity;
    	}
    	~SeqList()//析构函数
    	{
    		if (_pData)
    		{
    			free(_pData); // 释放堆上的空间
    			_pData = nullptr; // 将指针置为空
    			_capacity = 0;
    			_size = 0;
    		}
    	}
    private:
    	int* _pData;
    	size_t _size;
    	size_t _capacity;
    };
    int main()
    {
    	SeqList d1;
    	return 0;
    }
    

    4. 拷贝构造函数

    构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存在的类类型对象创建新对象时由编译器自动调用。

    拷贝构造函数特征
    1. 拷贝构造函数是构造函数的一个重载形式。
    2. 拷贝构造函数的参数只有一个且必须使用引用传参,使用传值方式会引发无穷递归调用。
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	//拷贝构造函数
    	//调用拷贝构造要先传参,传参又形成了一个新的拷贝构造,
    	//函数参数若为Date(Date d),则传参就是将d1的值传给的,相当于执行Date d = d1;
    	//相当于又进行一次拷贝构造。如此一来,就会形成一个递归操作而且没有结束条件,造成堆栈溢出。
    	//所以必须使用引用传参,形参是实参的别名,直接进入
    	Date(const Date& d)//Date& d = d1
    	{
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    	void Print()
    	{
    		cout << _year << "-" << _month << "-"<<_day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d1(2021,2,3);
    	//d2的值需要跟d1一样
    	Date d2(d1);//等价于Date d2 = d1;都是拷贝构造
    	d1.Print();
    	d2.Print();
    	return 0;
    }
    
    1. 若未显示定义,系统生成默认的拷贝构造函数。
      默认的拷贝构造函数对象按内存存储按字节序完成拷贝,这种拷贝我们叫做浅拷贝。
    2. 那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,我们还需要自己实现吗?当然像
      日期类这样的类是没必要的。
    class Stack
    {
    public:
    	Stack(int capacity = 4)
    	{
    		_a = (int*)malloc(sizeof(int)*capacity);
    		_capacity = capacity;
    		_size = 0;
    	}
    	~Stack()
    	{
    		free(_a);//释放栈上的空间
    		_a = nullptr;//将指针置为空
    		_capacity = 0;
    	}
    private:
    	int* _a;
    	int _size;
    	int _capacity;
    };
    int main()
    {
    	Stack st1;
    	Stack st2(st1);
    	//函数存在栈里,后定义的先调用析构函数,先调用st2,调用之后在析构函数中_a被free掉,变成野指针,再调用st1,无法进行二次释放。
    	//像stack这样管理着内存资源的类,浅拷贝是不行的,得搞成深拷贝。
    	//Stack st2 = st1;
    	return 0;
    }
    

    5. 赋值操作符重载

    运算符重载

    函数重载:函数名相同,参数不同
    运算符重载:自定义类型可以像内置类型一样去用运算符

    函数名字为:关键字operator后面接需要重载的运算符符号。
    1.不能通过连接其他符号来创建新的操作符:比如operator@
    2.用于内置类型的操作符,其含义不能改变,例如:内置的整型 + ,不能改变其含义。
    3.作为类成员的重载函数时,其形参看起来比成员函数的操作数数目少1个。
    4.操作符有一个默认的形参this,限定为第一个形参。
    5…*、::、sizeof 、 ? : 、.注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

     //全局的operator==和operator>
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	//d1==d2 -> d1.operator==(d2) -> d1.operator==(&d1,d2);
    	bool operator == (Date d2)
    	{
    		return _year == d2._year
    			&& _month == d2._month
    			&& _day == d2._day;
    	}
    	//d1>d2 -> d1.operator>(d2) -> d1.operator>(&d1,d2);
    	bool operator>(const Date& d)
    	{
    		if (_year > d._year)
    		{
    			return true;
    		}
    		else if (_year == d._year)
    		{
    			if (_month > d._month) 
    			{
    				return true;
    			}
    			else if (_month == d._month)
    			{
    				if (_day > d._day)
    				{
    					return true;
    				}
    			}
    		}
    		return false;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    // 这里会发现运算符重载成全局的就需要成员变量是共有的,那么问题来了,封装性如何保证?
    // 这里其实可以用我们后面学习的友元解决,或者干脆重载成成员函数。
    int main()
    {
    	Date d1(2021, 2, 4);
    	Date d2(d1);
    	//operator == (d1,d2);
    	//d1 == d2;
    	//d1.operator == (&d1,d2);
    	d1 == d2;
    
    	return 0;
    }
    
    赋值运算符重载

    赋值运算符注意四点:

    1. 参数类型
    2. 返回值
    3. 检测是否自己给自己赋值
    4. 返回*this
    5. 一个类如果没有显式定义赋值运算符重载,编译器也会生成一个,完成对象按字节序的值拷贝。
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	d2 = d3
    	Date& operator=(const Date& d)
    	{
    		if (this != &d)
    		{
    			_year = d._year;
    			_month = d._month;
    			_day = d._day;
    		}
    		return *this;
    	}
    //operator=跟拷贝构造函数一样,我们不实现,编译器会生成一份默认的,对于Date
    //默认的和重载的都可以用。像stack这样的类,需要自己实现深拷贝。
    	//原因是析构的时候回释放两次
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d1(2021, 2, 4);
    	Date d3(2021, 3, 1);
    	d1 = d3;
    	return 0;
    }
    

    注意:

    Date d2 = d1;//定义的同时赋值都是拷贝构造
    d2 = d1;//定义后才赋值就是赋值运算符重载
    

    6.const成员

    6.1 const修饰类的成员函数

    将const修饰的类成员函数称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改。

    class Date
    {
    public :
    	void Display ()
    	{
    		cout<<"Display ()" <<endl;
    		cout<<"year:" <<_year<< endl;
    		cout<<"month:" <<_month<< endl;
    		cout<<"day:" <<_day<< endl<<endl ;
    	}
    	void Display () const
    	{
    		cout<<"Display () const" <<endl;
    		cout<<"year:" <<_year<< endl;
    		cout<<"month:" <<_month<< endl;
    		cout<<"day:" <<_day<< endl<<endl;
    	}
    private :
    	int _year ; // 年
    	int _month ; // 月
    	int _day ; // 日
    };
    void Test ()
    {
    	Date d1 ;
    	d1.Display ();
    	const Date d2;
    	d2.Display ();
    }
    

    需要思考几个问题:

    1. const对象可以调用非const成员函数吗?
      不行!const修饰的对象,只有读权限没有写权限。
    2. 非const对象可以调用const成员函数吗?
      可以!权限可以缩小不可以放大!
    3. const成员函数内可以调用其它的非const成员函数吗?
      不可以!
    4. 非const成员函数内可以调用其它的const成员函数吗?
      可以!
    展开全文
  • 定义书类Book类: 1) 每本书的信息包含书名(C++string类型)和单价; 2) 定义两个构造函数:带一个参数的构造函数、带两个...新手小白构造函数老师讲的太快没学懂,大佬帮忙解析一下吗, 相关链接注释更好。
  • c语言简单粗暴的强制类型转换,当然c++也。问,可以将一个数字强制类型转换为一个类吗?class TestCls { public: int a; };int main(void) { TestCls t = 10; return 0; }这样编译肯定编程报错: 加上强制...
  • 假设构造函数是虚函数, 虚函数存在于虚函数表中, 而去找虚函数表又需要虚函数指针, 而虚函数表指针又存在于对象中, 这样就矛盾了: 都没有生成对象, 哪什么虚函数表指针呢? 那么问题又来了,析构函数可以是...
  • 首先定义类Person class Person{ public:  string name;... //默认构造函数 Person(string nam):name(nam){} void operator=(const Person& p){ //赋值构造函数 this->name=...
  • 拷贝构造函数

    2019-10-07 04:14:21
    可以,我们可以将第一个对象的数据变量的值分别赋给另一个对象的数据变量,但是,如果数据变量数很多的话那将是很麻烦的,这时候我们就需要拷贝构造函数。 拷贝构造函数是一种特殊的构造函数,因为它也是用来构造...
  • 问题: 1. 拷贝构造函数是构造函数吗? 是的。在创建对象时是被自动调用的构造函数的一...拷贝构造函数有什么特殊性? 专门命名的原因是拷贝构造函数具有特殊性,特殊在于:如果一个类没有编写拷贝构造函数,则系统为它
  • 构造函数是特殊的成员函数,名字与类名相同,创造自己类型的对象时由编译器自动调用,在对象的每个生命周期只调用一次,让其每个数据成员都一个合适的初始值。虽然他的名字叫构造但他不负责开空间创建对象,而是...
  • 类和对象2 ( 类的成员函数、构造函数、析构函数、拷贝构造函数、赋值运算符重载、const成员) ...构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都一个...
  • (1)普通构造函数 (2)复制构造函数 (3)析构函数  其他成员函数如果需要请自行设计。 要求:数据是设置成私有 在主函数测试:使用对象数组方法创建3个电脑、使用对象复制方法创建3个电脑(一共6...
  • 如果将虚函数、构造函数和析构函数结合起来会怎么样的效果呢? 构造函数可以是虚函数吗?答:构造函数不可以是虚函数!基于以下几点原因:(1)构造一个对象的时候,必须知道对象的实际类型,而虚函数行为是在运行...
  • 论坛中回答一个别人问题 ...我知道在数据成员默认构造函数时是不同的,但对其他类型的成员呢?其他类型成员的初始化和赋值区别吗?==================================================================
  • 2.1 概念:构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都 一个合适的初始值,并且在对象的生命周期内只调用一次。 2.2 特性 构造...
  • 使用构造函数创建对象函数M实际上也是Function类型的一个实例那么 Function __proto__ 属性吗?Object.prototype 没有__proto__?使用对象字面量创建对象使用Object.create()创建对象总结 说一些题外话 在最近的...
  • Complex::Complex(float R,float I) //带参数构造函数的实现 { real=R; imaginary=I; } Complex::Complex(Complex &c){ real=c.real; imaginary=c.imaginary; cout; } void Complex::getRI(float R...
  • 在读这一节的类容之前,我觉得构造函数我都用了至少几千上万遍了,还会什么新鲜的东西吗?经过仔细的阅读这一节,发现这样一个小小的主题,我不知道的并且对我们写程序至关重要的原来还有这么多... 1. 并不是所有...
  • //定义构造函数 Person(int age) { m_Age = age; cout 构造函数!" ; } //定义拷贝构造函数 Person(const Person& p) { m_Age = p.m_Age; cout 拷贝构造函数!" ; ...
  • 构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都一个合适的初始值,并且在对象的生命周期内只调用一次。 如果用户没有显示定义构造函数,C++编译器会自动...
  • 构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都 一个合适的初始值,并且在对象的生命周期内只调用一次。 2.2 构造函数特性 构造函数是特殊的成员函数,需要...
  • 题记,你知道的编程语言中哪些类型的函数呢?如果你学过C++的,你知道内联函数吗?...C++中类的构造函数和析构函数(一) C++编程之运算符重载 文章目录常规函数宏函数内联函数 常规函数    &...
  • C++转换函数

    千次阅读 2014-06-24 22:54:20
    在C++中,可以利用构造函数将一个int型变量转换为一个类对象,如CMyClass a...构造函数只能用于某种类型到类类型的转换.要进行相反的转换,则需要使用重载操作符函数--转换函数来实现. 转换函数是用户定义的强制类型
  • 结构体中可以有函数吗? C++ 里可以在结构体内定义函数,用法和class定义类是一样的,即:struct 和 class用法相同。但是struct默认的是public,而class默认为private。 在C中的情况详见:C语言结构体中如何包含函数 ...
  • 构造函数不能用虚拟,因为用也没用,不管是在栈上构造对象,还是在堆上构造对象,也不管你以后是否使用父类的指针或引用来指向或引用这个对象,在构造的那“一瞬间”,总归要指明要构造对象的具体类型,所以,对象在...
  • 1.类的六个默认成员函数 ...2.1构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都 一个合适的初始值,并且在对象的生命周期内只调用一次。...
  • 构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用,保证每个数据成员都一个合适的初始值,并且在对象的生命周期内只调用一次。 2.1 特性 构造函数是特殊的成员函数,需要注意的是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 415
精华内容 166
关键字:

构造函数有函数类型吗