精华内容
下载资源
问答
  • 2021-05-23 01:13:33

    在这里,我们将学习如何使用C ++中的构造函数来初始化对象数组?

    在此程序中,我们将定义一个类并声明对象数组,声明对象(对象数组)将通过构造函数进行初始化。

    在这里,我们将定义一个名为person的类,它具有两个成员的名称和年龄。这些成员将通过构造函数初始化(default和parameterized)。

    程序使用构造函数初始化C ++中的对象数组#include 

    #include 

    using namespace std;

    class person

    {

    private:

    char name[50];

    int age;

    public:

    //默认构造函数

    person()

    {

    strcpy(name,"N/A");

    age=0;

    }

    //带默认参数的参数化构造函数

    person(char *name, int age=18)

    {

    strcpy(this->name,name);

    this->age=age;

    }

    //显示值的功能

    void display()

    {

    cout<

    }

    };

    int main(){

    //类对象声明的数组

    person per[4]={"ABC",person("PQR"),person("XYZ",30)};

    per[0].display();

    per[1].display();

    per[2].display();

    per[3].display();

    return 0;

    }

    更多相关内容
  •  Derive 类构造函数两个 Base 类型的参数,分别赋给该类两个 Base 类型的成员变量 b1、b2,一个使用初始化列表,一个使用等于号赋值。输出结果如下:  前两行输出是主函数前两行构造 b1、b2 对像时调用的带...
  • 如果我们有一个类成员,它本身是一个类或者是一个结构,而且这个成员它只有一个带参数的构造函数,而没有默认构造函数,这时要对这个类成员进行初始化,就必须调用这个类成员的带参数的构造函数,如果没有初始化列表...
  • 有时,在一个类中有几个构造函数,以容纳某些可选参数,这些构造函数都包含一些共同的代码。  例如,下面的情况: class Car { private string description; private uint nWheels; public Car(string model,...
  • 构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表,每个数据成员后面跟一个放在括号中的初始化式。例如: class CExample { public: int a; float b; //构造函数初始化列表 CExample(): a(0...
  • 创建构造函数带参数的对象数组(构造函数初始化列表) #include<iostream> using namespace std; class node{//声明 public: node(int a,int b); ~node(); void print(); private: int x,y; }; //...

    菜鸟生成记(82)

    创建构造函数带参数的对象数组(构造函数初始化列表)

    两种写法;

    (1)使用构造函数初始化列表,同时赋予默认值;创建对象数组比较简单
    (2)使用构造函数进行成员赋值,不过创建对象数组,有点儿麻烦!

    (1)

    #include<iostream>
    using namespace std;
    class node{//声明 
    	public:
    		node(int a,int b);
    		~node();
    		void print();
    	private:
    		int x,y;	
    };
    //定义 
    node::node(int a=0,int b=0):x(a),y(b)
    {//构造函数用初始化列表,同时要给予默认值 
    //a=0,b=0:成员变量初始化默认值(0,0) 
    	;
    }
    node::~node()
    {
    	cout<<"这个对象终结了!"<<endl;
    }
    void node::print()
    {
    	cout<<x<<" "<<y<<endl;
    }
    int main()
    {
    	//动态创建构造函数带参数的对象 
    	node *t=new node;
    	t->print();
    	//动态创建构造函数带参数的对象数组  
    	node *a=new node[10];
    	//创建10个对象 
    	
    	//打印第10个的对象的成员 
    	a[9].print();
    	delete []a;
    	delete t;
    	return 0;
    }
    

    (2)

    #include<iostream>
    using namespace std;
    class node{//声明 
    	public:
    		node(int a,int b);
    		~node();
    		void print();
    	private:
    		int x,y;	
    };
    //定义 
    node::node(int a,int b)
    {
    	x=a,y=b;
    }
    node::~node()
    {
    	cout<<"这个对象终结了!"<<endl;
    }
    void node::print()
    {
    	cout<<x<<" "<<y<<endl;
    }
    int main()
    {
    	//动态创建构造函数带参数的对象 
    	node *t=new node(2,3);
    	t->print();
    	//动态创建构造函数带参数的对象数组  
    	node *a=(node*)operator new(sizeof(node)*10);
    	//创建10个对象 
    	for(int i=0;i<10;i++)
    	{//可以理解为10个对象初始化 
    		new(&a[i])node(1,2);
    	}
    	//打印第10个的对象的成员 
    	a[9].print();
    	delete []a;
    	delete t;
    	return 0;
    }
    
    
    展开全文
  • c++ 构造函数初始化过程

    千次阅读 2018-09-14 11:26:52
    每个类都会为它的对象定义初始化的方式,用一个或几个特殊的函数去控制对象的初始化,我们把这些特殊的函数叫做 构造函数。  那么,问题来了,构造函数作用是什么?  答:为了初始化对象的数据成员。就是简单。...

        每个类都会为它的对象定义初始化的方式,用一个或几个特殊的函数去控制对象的初始化,我们把这些特殊的函数叫做 构造函数。

        那么,问题来了,构造函数作用是什么?

        答:为了初始化对象的数据成员。就是简单。别把构造函数想着多复杂。

        那么,问题又来了,构造函数和普通的成员函数有什么相似和区别呢?

        答: 构造函数与函数名与类名同名,没有返回值类型,有一个参数列表(0个或多个形参),有一个函数体(可以为空)。

        刚说到,可以定义一个或几个构造函数,那么不同的构造函数互为重载函数,(即 各个构造函数间形参个数或形参类型不同)

        好,说到这,什么是构造函数,以及为什么要定义构造函数已经说得很清楚了。

        补充一点, 构造函数不能定位为const, 因为类的const对象,直到构造函数完成后,才真正获得其 const属性,所以,在构造函数中可以对 const对象的成员变量写值。

        接下来用几个例子说明构造函数,以及其初始化的过程。

     

    // a.h

    #include <string>

    #include <istream>

        class A

        {

         public:

             A() = default;

             A(std::string book) : bookNo(book) {}

             A(std::string book, size_t cnt, double price) : bookNo(book), count(cnt), revenue(price) {}

             A(std::istream & in); 

     

         private:

             std::string bookNo;

             size_t   count = 0;

             double   revenue = 0.0;

        };

     

    // a.cpp 

    #include "a.h"

          A::A(std::istream &in)

         {

             in >> bookNo >> count >> revenue;

         }

     

         首先,如果自定义一个类,然而并没有自定义任何构造函数,那么,一般编译器会自动帮我生成一个 合成默认构函数,

         问题来了,什么是默认构造函数?

         它也是构造函数的一种,不过比较特殊,它没有形参。

         又来一个问题, 它怎么初始化?

         我们知道,任何时候创建一个类对象都会调用构造函数,如果创建对象的时候,没有初值,一般调用默认构造函数,合成默认构造函数的初始化过程和块中定义的内置类型或者复合类型(数组或指针)一样执行默认初始化。直白一点说就是,如果在类内定义内置类型或者复合类型的成员,它执行默认初始化,即 bookNo会调用string的默认构造函数,而 count 和 revenue属于内置类型,如果有类型初始值,初始化为类内初始值,如果没有类内初始值,则内置类型 count 和 revenue 将产生未定义值。

        所以,一般类的定义,都需要提供自定义的默认构造函数,为什么???

        原因有三:

        第一、如果一个类定义了任何一个或几个构造函数,那么编译器就不会再为你生成合成默认构造函数,如果不自定义一个默认构造函数,则就不存在默认构造函数了,通常,如果定义了一个构造函数,说明我们想控制类的初始化,那么,通常所有的情况都需要控制,所以,需要自定义一个默认构造函数。

        第二、使用合成默认构造函数会执行错误的行为。如果类内定义了内置类型或者复合类型(数据或指针),如果没有提供类内初始值,则这些数据成员将产生未定义行为。所以,需要自定义一个默认构造函数。

        第三、某些类编译器不能生成合成默认的构造函数。比如,一个类中含有其他类的对象,而这个类对象没有默认构造函数,此时,将不能生成合成默认构造函数。所以,需要自定义一个默认构造函数。

       综上所述, 一般类的定义,需要自定义一个默认构造函数。

       回归例子, 上面的例子中

       A() = default;   用到了 = default  这是c++11引入的, 大意就是显示调用编译器为我们生成一个合成默认构造函数。

       调用此构造函数的初始化过程分为两步:

       第一步: 因为是默认构造,如果含有类内初始值,先用类内初始值初始化;

       第二步:如果没有类内初始值,采用默认初始化(这个内容后面再开博深入讲)。此处,就相当于在类内对内置类型默认初始化。

       再来说说 A(std::string book) : bookNo(book) {} 此处构造函数有一个参数, 并且多了 冒号开头 到 { 之间的内容,这些称为构造函数的初始值列表。

       这个函数的初始化过程如下:

       第一、bookNo 成员 在初始值列表显示调用string构造函数初始化,其它两个成员变量 count 和 revenue 并未显示初始化,此时,这两个变量按照合成默认构造函数的初始化过程进行初始化。

       第二、count 和 revenue 初始化, 如果有类内初始值,就采用类内初始值初始化,如果没有,会出现未定义行为。此处,有类内初始值, count 被初始化为0,revenue 被初始化为 0.0 。

       继续,  A(std::string book, size_t cnt, double price) : bookNo(book), count(cnt), revenue(price) {} 此构造函数,所有的成员变量都提供了初始值列表显示初始化,没什么可讲的,很清楚。bookNo被初始化为book的值, count被初始化为 cnt的值,revenue被初始化为 price的值。

       下一个,A(std::istream & in);  此构造函数,声明在头文件,定义在cpp文件中,

       它得初始化过程如下:

       第一、它没有初始值列表,相当于为空,此时, bookNo 先调用string默认构造函数,初始化为空string对象, count 和 revenue 被类内初始值初始化为0

       第二、进入构造函数体,三个成员被赋值被其他的值,最终构造函数完成后的初始值,为从输入流中输入的对应值。

       好了,今天就先讲到这,以上例子仅仅为了说明初始的过程之用,省略了一些东西,还有不到之处,敬请忽略。

       留一个思考题,为什么类的const对象只能调用 const成员函数??? (以后再开博细讲...)

       告辞,各位!!!

        

    展开全文
  • C++ Primer中在讲构造函数初始化列表的时候有这么一段话:无论是在构造函数初始化列表中初始化成员,还是在构造函数体中对它们赋值,最终结果是相同的。不同之处在于,使用构造函数初始化列表的版本初始化数据成员,...
  • 1.构造函数初始化列使用方法 如图所示的类中只有两个数据成员,语法:构造函数后面要用冒号隔开,对于多个数据成员之间要用逗号隔开,赋值的时候要有括号而不能用等于号复制。 2.初始化列表特性 初始化列表由于构造...

    一.初始化列表

    1.构造函数初始化列使用方法

    在这里插入图片描述
    如图所示的类中只有两个数据成员,语法:构造函数后面要用冒号隔开,对于多个数据成员之间要用逗号隔开,赋值的时候要有括号而不能用等于号复制。

    2.初始化列表特性

    初始化列表由于构造函数执行:编译器会先给初始列表的成员。

    赋值再执行构造函数的代码。

    初始化列表只适用于构造函数。

    初始化列表可以初始化多个成员数据。

    3.初始化列表的必要性

    大家可能会想初始化列表的工作构造函数完全能够完成,为什么还要存在初始化列表呢!下面看一个例子。
    

    用构造函数来给常量赋值会发生语法错误
    在这里插入图片描述
    但是用初始化列表却可以完成这个工作。

    4.代码实例

    main函数文件:

    #include<iostream>
    #include<stdlib.h>
    #include<string>
    #include"teacher.h"
    using namespace std;
    
    /****************************************************************/
    /*自定义Teacher类
    *自定义有参默认构造函数
    *使用初始化列表初始化数据
    *数据成员:
    *	名字
    *	年龄
    *成员函数
    *	数据成员的封装函数
    *扩展
    #定义可以带最多学生个数,此为常量
    /****************************************************************/
    
    int main(void)
    {
    	Teacher t1("Merry",2,1000);
    	cout << t1.getName() << " " << t1.getAge() <<" "<<t1.getMax()<< endl;
    	//cout << t2.getName() << " " << t2.getAge() << endl;
    	system("pause");
    	return 0;
    
    }
    

    Teacher.h文件

    #include<string>
    using namespace std;
    
    class Teacher
    {
    public:
    	Teacher(string _name ="Jim", int _age = 1,int m=100);
    	void setName(string _name);
    	string getName();
    	void setAge(int _age);
    	int getAge();
    	int getMax();
    
    private:
    	string m_strName;
    	int m_iAge;
    	const int m_iMax;
    };
    
    

    Teacher.cpp文件(初始化列表)

    #include<iostream>
    #include<stdlib.h>
    #include<string>
    #include "Teacher.h"
    using namespace std;
    
    
    Teacher::Teacher(string _name, int _age,int m):m_strName(_name),m_iAge(_age),m_iMax(m)
    {
    	cout << "Teacher(string _name,int _age)" << endl;
    }
    
    int Teacher::getMax()
    
    {
    	return  m_iMax;
    }
    void Teacher::setName(string _name)
    {
    	m_strName = _name;
    }
    
    string Teacher::getName()
    {
    	return m_strName;
    }
    
    void Teacher::setAge(int _age)
    {
    	m_iAge = _age;
    }
    
    int Teacher::getAge()
    {
    	return m_iAge;
    }
    
    

    可以尝试不用初始化列表初始化const常量会发现错误
    在这里插入图片描述

    二.拷贝构造函数

    1.拷贝构造函数的用途

    如图当我们实例化对象stu1、stu2、stu3时本应该自动调用构造函数就会打印出三个Student的,但是事实是只打印了一个。原因就是后面两个调用的是拷贝构造函数。
    在这里插入图片描述

    2.拷贝构造函数的定义以及其特点

    在这里插入图片描述
    特点:
    *拷贝构造函数的参数是固定的不可以重载
    *如果有自定义拷贝构造函数则系统会自动生成一个默认的拷贝构造函数
    *当采用直接初始化或者复制初始化实例对象时系统会自动调用拷贝构造函数

    3.代码实例

    main函数文件:

    #include<iostream>
    #include<stdlib.h>
    #include<string>
    #include"teacher.h"
    using namespace std;
    
    /****************************************************************/
    /*自定义Teacher类
    *自定义拷贝构造函数
    *数据成员:
    *	名字
    *	年龄
    *成员函数
    *	数据成员的封装函数
    /****************************************************************/
    
    int main(void)
    {
    	Teacher t1;
    	Teacher t2 = t1;
    	Teacher t3(t1);
    	system("pause");
    	return 0;
    
    }
    
    

    Teacher.h文件

    #include<string>
    using namespace std;
    
    class Teacher
    {
    public:
    	Teacher(string _name = "Jim", int _age = 1);
    	Teacher(const Teacher &tea);
    	void setName(string _name);
    	string getName();
    	void setAge(int _age);
    	int getAge();
    private:
    	string m_strName;
    	int m_iAge;
    };
    
    

    Teacher.cpp文件

    #include<iostream>
    #include<stdlib.h>
    #include<string>
    #include "Teacher.h"
    using namespace std;
    
    
    Teacher::Teacher(string _name, int _age):m_strName(_name),m_iAge(_age)
    {
    	cout << "Teacher(string _name,int _age)" << endl;
    }
    
    Teacher::Teacher(const Teacher &tea)
    {
    	cout << "Teacher(const Teacher &tea)" << endl;
    }
    
    void Teacher::setName(string _name)
    {
    	m_strName = _name;
    }
    
    string Teacher::getName()
    {
    	return m_strName;
    }
    
    void Teacher::setAge(int _age)
    {
    	m_iAge = _age;
    }
    
    int Teacher::getAge()
    {
    	return m_iAge;
    }
    
    

    运行结果显示t2、t3的实例化都调用的是拷贝构造函数。
    在这里插入图片描述
    **注意:**拷贝构造函数不仅在前面实例化对象的时候会被调用,当出现参数传递的时候一样会自动调用拷贝构造函数。如图当test函数引用t1的时候一样会自动调用拷贝构造函数。
    在这里插入图片描述

    三.构造函数总结

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

    展开全文
  • C++构造函数初始化类对象

    万次阅读 多人点赞 2019-04-12 15:53:51
    文章目录一.构造函数二.构造函数的分类三.构造函数的写法 ...【5】构造函数通常用于对类内的数据进行初始化。 二.构造函数的分类 无参的构造函数 有参的构造函数 参数初始化表的构造函数【重点】 ...
  • 1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员; 2.进入构造函数后在构造函数中执行一般赋值与计算。 使用初始化列表有两个原因:原因1.必须这样做: 《C++ Primer》中提到在以下三种情况下需要使用...
  • 构造函数初始化数据成员 方法一:在构造函数体内进行数据成员的初始化 如下: class Point { public: Point(int tx,int ty){ x=tx; y=ty; } private: int x; int y; }; 构造函数也可以在类外定义: ...
  • C++类构造函数初始化列表与父类

    千次阅读 2020-12-05 15:53:08
    一、C++类构造函数初始化列表 class CExample { public: int a; float b; //构造函数初始化列表 CExample() : a(0), b(8.8) {} //构造函数内部赋值 CExample() { a = 0; b = 8.8; } }; 上面的例子中...
  • 1.构造函数初始化 在构造函数中用初始化列表初始化数据域 Class Person(parameterList): dataField1(value1), dataField2(value2) { // Something to do } 2. 为何需要构造函数初始化列表 背景:类的.....
  • C++构造函数初始化

    千次阅读 2018-06-14 10:09:39
    构造函数后面增加冒号一般有三种作用(1)对成员变量的初始化(2)对类成员对象初始化(3)对父类进行初始化示例1-对成员变量的初始化#include &lt;stdlib.h&gt; #include &lt;iostream&gt; using ...
  • c++ 构造函数初始化列表

    千次阅读 2018-08-09 15:04:44
    《C++ Primer》中提到在以下三种情况下需要使用构造函数初始化列表:  1. 需要初始化的类的成员变量是对象的情况;   2. 需要初始化的类的成员变量由const修饰的或初始化的类的引用成员变量;  3. 子类初始化...
  • 既然构造函数初始化列表和构造函数体内赋值都可以对成员变量赋值,那么二者有何区别,是不是二者等效呢?  构造函数可以分两个阶段进行:(1)初始化阶段;(2)普通计算阶段。计算阶段也就是由函数体内...
  • [C/C++]构造函数初始化

    千次阅读 2020-03-29 20:08:52
    构造函数也是一样的,构造函数的最重要的功能,就是初始化,所有和初始化有关的,都可以放在构造函数中,比如类内部成员的初始化等。 ②初始化方式:其实有三种方式初始化: (1)在声明成员变量的时候直接初始化...
  • C++中默认构造函数和构造函数初始化列表

    千次阅读 多人点赞 2018-12-13 10:59:45
    1、默认构造函数构造函数 (1)构造函数:C++用于构建类的新对象时需要调用的函数,该函数无返回类型!(注意:是“无”! 不是空!(void))。 (2)默认构造函数:默认构造函数是在调用时不需要显示地传入实参...
  • c++ 必须使用构造函数初始化列表初始化的情况

    千次阅读 多人点赞 2018-04-04 09:04:01
    1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员; 2.进入构造函数后在构造函数中执行一般赋值与计算。 使用初始化列表有两个原因: 原因1.必须这样做: 《C++ Primer》中提到在以下三种情况下需要使用...
  • c++成员变量初始化方法:声明时初始化、初始化列表、构造函数初始化 有人说在声明的时候初始化相当于在构造函数中初始化,其实不是的,成员变量初始化的顺序为:先进行声明时初始化,然后进行初始化列表初始化,最后...
  • 构造函数初始化(默认构造)

    千次阅读 2018-11-18 11:56:15
    默认构造函数时在未提供显示初始化时,用来创建对象的构造函数。也就是说,它是用于下面这种声明的构造函数: expa expa; 然后我们看下没有声明默认构造函数出错的例子: #include<ios...
  • 1、自定义类,并指定类的构造函数。  public class Test  {  public Test(string A, string B, string C, float D)  {  this.AA= A;  this.BB= B;  this.CC= C;  th...
  • C++之基类构造函数初始化

    千次阅读 2018-09-19 13:44:36
    定义一个基类:初始化需要传入一个整数 class mybase { public: mybase(int iType); virtual ~mybase(); public: int m_iType; }; 在定义一个子类,继承于mybase class my:public mybase { public: my(); ...
  • C#中:初始化器及构造函数初始化

    千次阅读 2019-05-05 18:55:03
    初始化器分为对象初始化器和集合初始化器。下面一一介绍。 对象初始化器 对象初始化器的作用,简单点说就是可以使我们初始化一个类的代码变得更简洁。比如下面这个类: class Person { public string Name { get...
  • C++ 构造函数初始化顺序

    千次阅读 2017-03-27 14:47:43
    构造函数初始化按照如下顺序进行 1. 首先构造虚拟基类,任何虚拟基类的构造函数按照它们被继承的顺序构造; 2. 其次构造非虚拟基类,任何非虚拟基类的构造函数按照它们被继承的顺序构造; 3. 接着构造成员对象,...
  • c++ 子类构造函数初始化及父类构造初始化

    万次阅读 多人点赞 2018-08-30 15:58:50
    我们知道,构造方法是用来初始化类对象的。如果在类中没有显式地声明构造函数,...因此,在创建子类对象时,为了初始化从父类中继承来的成员变量,编译器需要调用其父类的构造函数。如果子类的构造函数没有显示地调...
  • 有一个类A,其数据成员如下: class A { ... private: int a; public: const int b;...则构造函数中,成员变量一定要通过初始化列表来初始化的是...构造函数中,成员变量一定要通过初始化列表来初始化的有以下几种...
  • VC++中,构造函数初始化的方法和使用详细介绍。
  • C++构造函数初始化列表与赋值

    千次阅读 2018-03-05 15:55:02
    C++构造函数初始化列表与赋值C++类中成员变量的初始化有两种方式: 构造函数初始化列表和构造函数体内赋值。下面看看两种方式有何不同。 成员变量初始化的顺序是按照在那种定义的顺序。1 内部数据类型(char,int...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 827,980
精华内容 331,192
关键字:

构造函数初始化

友情链接: twaindsm-2.3.0.orig.zip