构造函数初始化成员变量

构造函数初始化成员变量
构造函数初始化成员变量

请问在构造函数中使用初始化清单和直接在构造函数内初始化成员变量有什么区别?

比如:

construct_function():var1(1),var2(2),var(3)

{}

construct_function()

{

var1 = 1;

var2 = 2;

var3 = 3;

}

有没有什么本质区别?

=============================================================================== =======

construct_function():var1(1),var2(2),var(3)

{}

初始化

construct_function()

{

var1 = 1;

var2 = 2;

var3 = 3;

}赋值

首先把数据成员按类型分类

1、内置数据类型,复合类型(指针,引用)

2、用户定义类型(类类型)

分情况说明:

对于类型1,在成员初始化列表和构造函数体内进行,在性能和结果上都是一样的。要是const类型的话只能使用初始化列表。

对于类型2,结果上相同,但是性能上存在很大的差别。

因为类类型的数据成员对象在进入函数体是已经构造完成,也就是说在成员初始化列表处进行构造对象的工作,这是调用一个构造函数,在进入函数体之后,进行的是对已经构造好的类对象赋值,又调用其拷贝赋值操作符才能完成(如果并未提供,则使用编译器提供的默认按成员赋值行为)。

举个例说明

class A;

class B

{

public:

B(){a = 3;}

private:

A a;

}

class A

{

public:

A(){}

A(int){value = 3;}

int value;

}

像上面,我们使a对象的value为3,调用一个A的构造函数+一个默认拷贝赋值符,才达到目的。B::B():a(3){}

像这样,只调用了一个构造函数就得到了所需的对象啦,所以性能好。

注意:对于const成员,无缺省构造函数的类对象成员,均需放在成员初始化列表。

再举个例子:

class A

{

public:

A(int i){}

};

class B

{

public:

B() : ci(3), a(3){}

private:

const int ci;

A a;

};

int main()

{

B b;

return 0;

}

对于const成员,无缺省构造函数的类对象成员,均需放在成员初始化列表。

C默认构造函数的作用

C#默认构造函数的作用 本文详细介绍C#默认构造函数的作用 构造函数主要用来初始化对象。它又分为静态(static)和实例(instance)构造函数两种类别。大家应该都了解如果来写类的构造函数,这里只说下默认构造函数的作用,以及在类中保留默认构造函数的重要性。实际上,我说错了。正确的说法是:以及在类中保留空参数构造函数的重要性。我们来写一个类A,代码如下: view plaincopy to clipboardprint? public class A { public int Number; //数字 public string Word; //文本 } //在Test类中实例化 public class Test { static void Main() { A a = new A(); //实例化,A()即为类A的默认构造函数 Console.WriteLine(“Number = {0}"nWord = {1}”,a.Number,a.Word); Console.read(); } } 输出的结果是: Number = 0 Word = ******************************* using System; class Point { public int x, y,z; public Point() { x = 0; y = 0; z = 0; } public Point(int x, int y,int z) { //把函数内容补充完整 this.x = x; this.y =y;

this.z =z; } public override string ToString() { return(String.Format("({0},{1},{2})", x, y,z)); } } class MainClass { static void Main() { Point p1 = new Point(); Point p2 = new Point(10,20,30); Console.WriteLine("三维中各点坐标:"); Console.WriteLine("点1的坐标为{0}", p1); Console.WriteLine("点2的坐标为{0}", p2); } } ******************************************************************************* ********* C#类的继承,构造函数实现及其调用顺序 类层层派生,在实例化的时候构造函数的调用顺序是怎样的? --从顶层基类开始向子类方向顺序调用无参构造. 默认构造(无参构造)和带参构造什么时候调用?--默认将从顶层父类的默认构造一直调用到当前类的默认构造. 下面是示例: /**//*--===------------------------------------------===--- 作者:许明会 日期:类的派生和构造函数间的关系,调用层次及实现 日期:2008年1月18日 17:30:43 若希望类能够有派生类,必须为其实现默认构造函数. 若类没有实现带参构造,编译器将自动创建默认构造函数. 若类实现了带参构造,则编译器不会自动生成默认构造. --===------------------------------------------===---*/ using System; namespace xumh { public class MyClass { public MyClass () {

c 类构造函数详解

这篇文章主要介绍了c++类构造函数示例,需要的朋友可以参考下 代码如下: //一、构造函数是干什么的 /* 类对象被创建时,编译系统对象分配内存空间,并自动调用该构造函数->由构造函数完成成员的初始化工作 eg: Counter c1; 编译系统为对象c1的每个数据成员(m_value)分配内存空间,并调用构造函数Counter( )自动地初始化对象,初始化之后c1的m_value值设置为0 故:构造函数的作用:初始化对象的数据成员。*/ class Counter { public: // 类Counter的构造函数,以类名作为函数名,无返回类型 Counter(){ m_value = 0; } private: int m_value; // 类私有的数据成员 } //二、构造函数的种类 #include using namespace std; class Complex { private : double m_real; double m_imag; public: //*无参数构造函数 // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数,函数为空,什么都不做 // 只要你写了一个下面的某一种构造函数,系统就不会再自动生成这样一个默认的构造函数,如果希望有一个这样的无参构造函数,则需要自己显示地写出来Complex(void) { m_real = 0.0; m_imag = 0.0; } //*一般构造函数(也称重载构造函数) //一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数,前提是参数的个数或者类型不同(基于c++的重载函数原理) //例如:你还可以写一个Complex(int num)的构造函数出来,创建对象时根据传入的参数不同调用不同的构造函数 Complex(double real, double imag)

定义构造函数的四种方法

定义类的构造函数 作者:lyb661 时间:20150613 定义类的构造函数有如下几种方法: 1、使用默认构造函数(类不另行定义构造函数):能够创建一个类对象,但不能初始化类的各个成员。 2、显式定义带有参数的构造函数:在类方法中定义,使用多个参数初始化类的各个数据成员。 3、定义有默认值的构造函数:构造函数原型中为类的各个成员提供默认值。 4、使用构造函数初始化列表:这个构造函数初始化成员的方式显得更紧凑。 例如:有一个学生类。其中存储了学生的姓名、学号和分数。 class Student { private: std::string name; long number; double scores; public: Student(){}//1:default constructor Student(const std::string& na,long nu,double sc); Student(const std:;string& na="",long nu=0,double sc=0.0); Student(const std:;string& na="none",long nu=0,double sc=0.0):name(na),number(nu),scores(sc){} ……….. void display() const; //void set(std::string na,long nu,double sc); }; ......... Student::Student(const std::string& na,long nu,double sc) { name=na; number=nu; scores=sc; } void Student::display()const { std::cout<<"Name: "<

构造函数

c++构造函数的知识在各种c++教材上已有介绍,不过初学者往往不太注意观察和总结其中各种构造函数的特点和用法,故在此我根据自己的c++编程经验总结了一下c++中各种构造函数的特点,并附上例子,希望对初学者有所帮助。 c++类的构造函数详解 一、构造函数是干什么的 class Counter { public: // 类Counter的构造函数 // 特点:以类名作为函数名,无返回类型 Counter() { m_value = 0; } private: // 数据成员 int m_value; } 该类对象被创建时,编译系统对象分配内存空间,并自动调用该构造函数->由构造函数完成成员的初始化工作 eg: Counter c1; 编译系统为对象c1的每个数据成员(m_value)分配内存空间,并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0 故: 构造函数的作用:初始化对象的数据成员。 二、构造函数的种类 class Complex { private : double m_real; double m_imag;

public: // 无参数构造函数 // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数,函数为空,什么都不做 // 只要你写了一个下面的某一种构造函数,系统就不会再自动生成这样一个默认的构造函数,如果希望有一个这样的无参构造函数,则需要自己显示地写出来 Complex(void) { m_real = 0.0; m_imag = 0.0; } // 一般构造函数(也称重载构造函数) // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数,前提是参数的个数或者类型不同(基于c++的重载函数原理) // 例如:你还可以写一个Complex( int num)的构造函数出来 // 创建对象时根据传入的参数不同调用不同的构造函数 Complex(double real, double imag) { m_real = real; m_imag = imag; } // 复制构造函数(也称为拷贝构造函数) // 复制构造函数参数为类对象本身的引用,用于根据一个已存在的对象复制出一个新的该类的对象,一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中// 若没有显示的写复制构造函数,则系统会默认创建一个复制构造函数,但当类中有指针成员时,由系统默认创建该复制构造函数会存在风险,具体原因请查询有关“浅拷贝”、“深拷贝”的文章论述 Complex(const Complex & c) { // 将对象c中的数据成员值复制过来 m_real = c.m_real; m_img = c.m_img; } // 类型转换构造函数,根据一个指定的类型的对象创建一个本类的对象 // 例如:下面将根据一个double类型的对象创建了一个Complex对象 Complex::Complex(double r) { m_real = r; m_imag = 0.0;

构造函数初始化成员变量

请问在构造函数中使用初始化清单和直接在构造函数内初始化成员变量有什么区别? 比如: construct_function():var1(1),var2(2),var(3) {} 和 construct_function() { var1 = 1; var2 = 2; var3 = 3; } 有没有什么本质区别? =============================================================================== ======= construct_function():var1(1),var2(2),var(3) {} 初始化 construct_function() { var1 = 1; var2 = 2; var3 = 3; }赋值 首先把数据成员按类型分类 1、内置数据类型,复合类型(指针,引用) 2、用户定义类型(类类型) 分情况说明: 对于类型1,在成员初始化列表和构造函数体内进行,在性能和结果上都是一样的。要是const类型的话只能使用初始化列表。 对于类型2,结果上相同,但是性能上存在很大的差别。 因为类类型的数据成员对象在进入函数体是已经构造完成,也就是说在成员初始化列表处进行构造对象的工作,这是调用一个构造函数,在进入函数体之后,进行的是对已经构造好的类对象赋值,又调用其拷贝赋值操作符才能完成(如果并未提供,则使用编译器提供的默认按成员赋值行为)。 举个例说明 class A; class B {

public: B(){a = 3;} private: A a; } class A { public: A(){} A(int){value = 3;} int value; } 像上面,我们使a对象的value为3,调用一个A的构造函数+一个默认拷贝赋值符,才达到目的。B::B():a(3){} 像这样,只调用了一个构造函数就得到了所需的对象啦,所以性能好。 注意:对于const成员,无缺省构造函数的类对象成员,均需放在成员初始化列表。 再举个例子: class A { public: A(int i){} }; class B { public: B() : ci(3), a(3){} private: const int ci; A a; }; int main() { B b; return 0; } 对于const成员,无缺省构造函数的类对象成员,均需放在成员初始化列表。

Java默认构造函数的作用

class Person { private String name=""; private int age=0; public Person() { System.out.println("person无参数构造函数"); } public Person(String name,int age) { https://www.360docs.net/doc/307872101.html,=name; this.age=age; System.out.println("person 2 参数的构造函数"); } } class Student extends Person { private String school; private String grade; public Student() { System.out.println("student 无参数的构造函数"); } public Student(String name ,int age,String school) { System.out.println("student 3 参数的构造函数"); } public Student(String name ,int age,String school,String grade) { super(name,age); this.school=school;

this.grade=grade; System.out.println("student 4 参数的构造函数,super()."); } } class Test { public static void main(String [] args) { System.out.println("st1:"); Student st2=new Student(); System.out.println("---------------------------"); System.out.println("st2:"); Student st=new Student("zhangshan",76,"武大"); System.out.println("---------------------------"); System.out.println("st3:"); Student st3=new Student("lisi",24,"武大","研究生"); } } /* ======================================= 输出如下: E:JavaWork>java Test st1: person无参数构造函数 student 无参数的构造函数 --------------------------- st2: person无参数构造函数 student 3 参数的构造函数 --------------------------- st3:

C#中构造函数使用方法

C#构造函数是在创建给定类型的对象时执行的类方法。构造函数具有与类相同的名称,它通常初始化新对象的数据成员。不带参数的构造函数称为“默认构造函数”。无论何时,只要使用new 运算符实例化对象,并且不为new 提供任何参数,就会调用默认构造函数。除非类是static 的,否则C# 编译器将为无构造函数的类提供一个公共的默认构造函数,以便该类可以实例化。 构造函数必须是在类里的一级声明,并且命名为类名, 形式为:修饰符类名(参数类型1,参数名1,。。。) 例如 class A { public int x, y; public string s; // 默认构造函数 public A() { x = 0; y = 0; } //带参数的构造函数 public A(string a) { this.s=a; } } 一般函数的声明则不受这些约束 只要定义在命名空间内,命名形式为:修饰符返回值类型函数名(参数类型1,参数名1,。。。) 例如:private static void Main(string args) 声明了一个私有的静态主函数,无返回值,参数为args,string类型vvv 一、C#构造函数?Construct,Function 构造函数是一种特殊的成员函数,它主要用于为对象分配存储空间,对数据成员进行初始化. 构造函数具有一些特殊的性质: (1)构造函数的名字必须与类同名; (2)构造函数没有返回类型,它可以带参数,也可以不带参数; (3)声明类对象时,系统自动调用构造函数,构造函数不能被显式调用; (4)构造函数可以重载,从而提供初始化类对象的不同方法; (5)若在声明时未定义构造函数,系统会自动生成默认的构造函数,此时构造函数的函数体为空.

C类构造函数初始化列表

类构造函数初始化列表 初始化列表地定义在使用编程地过程当中,常常需要对类成员进行初始化,通常地方法有两种:一种是构造函数内对类地成员赋值,一种则是使用初始化列表地构造函数显式地初始化类地成员. 构造函数初始化列表以一个冒号开始,接着是以逗号分隔地数据成员列表,每个数据成员后面跟一个放在括号中地初始化式.例如:{ : ; ; 构造函数初始化列表(): ()() {} 构造函数内部赋值() { ; ; } }; 从技术上说,用初始化列表来初始化类成员比较好,但是在大多数情况下,两者实际上没有什么区别.第二种语法被称为成员初始化列表,之所以要使用这种语法有两个原因:一个原因是必须这么做,另一个原因是出于效率考虑初始化列表地必要性初始化和赋值对内置类型地成员没有什么大地区别,像上面地任一个构造函数都可以.但在一些情况下,初始化列表可以做到构造函数做不到地事情: 、类里面有类型地成员,它是不能被赋值地,所以需要在初始化列表里面初始化它; 、引用类型地成员(也就是名字成员,它作为一个现有名字地别名),也是需要在初始化列表里面初始化地,目地是为了生成了一个其名字成员在类外可以被修改而在内部是只读地对象;

、需要调用基类地构造函数,且此基类构造函数是有参数地; 、类里面有其他类类型地成员,且这个“其他类”地构造函数是有参数地. 举个例子:设想你有一个类成员,它本身是一个类或者结构,而且只有一个带一个参数地构造函数. { : ( ) { ... } }; 因为有一个显式声明地构造函数,编译器不产生一个缺省构造函数(不带参数),所以没有一个整数就无法创建地一个实例. * ; 出错!! * (); 如果是另一个类地成员,你怎样初始化它呢?答案是你必须使用成员初始化列表. { ; : (); }; 必须使用初始化列表来初始化成员 () : () {……} 没有其它办法将参数传递给. 情况和其实一样地道理.如果成员是一个常量对象或者引用也是一样.根据地规则,常量对象和引用不能被赋值,它们只能被初始化. 初始化列表与构造函数赋值地效率比较首先把数据成员按类型分类并分情况说明: .内置数据类型,复合类型(指针,引用) 在成员初始化列表和构造函数体内进行,两者在性能和结果上都是一样地 .用户定义类型(类类型) 两者在结果上相同,但是性能上存在很大地差别. 因为编译器总是确保所有成员对象在构造函数体执行之前初始化,所以对于用户自定义类型(类),在初始化列表中只会调用类地构造函数,在构造函数体中赋值就会先调用一次类地构造函数,然后再调用一次类地赋值操作符函数. 显然后者在性能上有所损失,特别对于构造函数和赋值操作符都需要分配内存空间地情况,使用初始化列表,就可以避免不必要地多次内存分配. 举个例子:假定你有一个类具有一个类型地成员,你想把它初始化为" .".你有两种选择: 、使用构造函数赋值()

C++构造函数详解及显式调用构造函数

C++构造函数详解及显式调用构造函数 c++类的构造函数详解 一、构造函数是干什么的 class Counter { public: // 类Counter的构造函数 // 特点:以类名作为函数名,无返回类型 Counter() { m_value = 0; } private: // 数据成员 int m_value; } 该类对象被创建时,编译系统对象分配内存空间,并自动调用该构造函数->由构造函数完成成员的初始化工作 eg: Counter c1; 编译系统为对象c1的每个数据成员(m_value)分配内存空间,并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0 故: 构造函数的作用:初始化对象的数据成员。 二、构造函数的种类 class Complex { private : double m_real; double m_imag; public: // 无参数构造函数 // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数,函数为空,什么都不做 // 只要你写了一个下面的某一种构造函数,系统就不会再自动生成这样一个默认的构造函数,如果希望有一个这样的无参构造函数,则需要自己显示地写出来 Complex(void) { m_real = 0.0; m_imag = 0.0; } // 一般构造函数(也称重载构造函数) // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数,前提是参数的个数或者

类型不同(基于c++的重载函数原理) // 例如:你还可以写一个Complex( int num)的构造函数出来 // 创建对象时根据传入的参数不同调用不同的构造函数 Complex(double real, double imag) { m_real = real; m_imag = imag; } // 复制构造函数(也称为拷贝构造函数) // 复制构造函数参数为类对象本身的引用,用于根据一个已存在的对象复制出一个新的该类的对象,一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中 // 若没有显示的写复制构造函数,则系统会默认创建一个复制构造函数,但当类中有指针成员时,由系统默认创建该复制构造函数会存在风险,具体原因请查询有关“浅拷贝” 、“深拷贝”的文章论述 Complex(const Complex & c) { // 将对象c中的数据成员值复制过来 m_real = c.m_real; m_imag = c.m_imag; } // 类型转换构造函数,根据一个指定的类型的对象创建一个本类的对象, //需要注意的一点是,这个其实就是一般的构造函数,但是对于出现这种单参数的构造函数,C++会默认将参数对应的类型转换为该类类型,有时候这种隐私的转换是我们所不想要的,所以需要使用explicit来限制这种转换。 // 例如:下面将根据一个double类型的对象创建了一个Complex对象 Complex(double r) { m_real = r; m_imag = 0.0; } // 等号运算符重载(也叫赋值构造函数) // 注意,这个类似复制构造函数,将=右边的本类对象的值复制给等号左边的对象,它不属于构造函数,等号左右两边的对象必须已经被创建 // 若没有显示的写=运算符重载,则系统也会创建一个默认的=运算符重载,只做一些基本的拷贝工作 Complex &operator=( const Complex &rhs ) { // 首先检测等号右边的是否就是左边的对象本身,若是本对象本身,则直接返回 if ( this == &rhs ) { return *this; } // 复制等号右边的成员到左边的对象中 this->m_real = rhs.m_real;

构造方法

Java构造方法 一、构造方法及其作用 new一个对象的时候要用到构造函数,例如Hello hello = new Hello();这时调用的是Hello的无参数构造方法;Hello hello = new Hello("hi");这个是调用Hello有参数构造方法,如果Hello类中已经有了一个有参数的构造方法,这时再使用Hello hello = new Hello();来创建对象的时候就会出错,这就是为什么强调写了有参数的构造方法就最好加一个无参数的构造方法. 特点: 1、构造方法名一定与类同名 2、构造方法无返回值类型(void 也不行),不能被static、final、synchronized、abstract、native等修饰。因为构造方法用于初始化一个新建的对象,所以用static修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象,因此用synchronized修饰没有必要。 3、构造方法可以没有(默认一个无参构造方法),也可以有多个构造方法,他们之间构成重载关系,表达对象的多种初始化行为 4、如果定义有参构造函数,则无参构造函数将被自动屏蔽 5、构造方法不能被继承,但子类可以通过super调用父类的构造方法 6、构造方法不能手动调用,在创建类实例的时候自动调用构造方法 作用: 在多数情况下,初始化一个对象的最终步骤是去调用这个对象的构造方法。构造方法负责对象的初始化工作,为实例变量赋予合适的初始值。 二、默认构造方法 在JAVA中如果不写构造方法的话,会默认加上一个无参数的构造方法,但是如果已经有了一个有参数的构造方法,那么无参数的构造方法就不会默认被加上。此时创建无参数对象时,报错。 publicclass Sample1 { } publicclass Sample2 { public Sample2(int a) { System.out.println("My Constructor");

C++类构造函数初始化列表

C++类构造函数初始化列表 初始化列表的定义 在使用C++编程的过程当中,常常需要对类成员进行初始化,通常的方法有两种:一种是构造函数内对类的成员赋值,一种则是使用初始化列表的构造函数显式的初始化类的成员。 构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表,每个数据成员后面跟一个放在括号中的初始化式。例如: class CExample { public: int a; float b; //构造函数初始化列表 CExample(): a(0),b(8.8) {} //构造函数内部赋值 CExample() { a=0; b=8.8; } }; 从技术上说,用初始化列表来初始化类成员比较好,但是在大多数情况下,两者实际上没有什么区别。第二种语法被称为成员初始化列表,之所以要使用这种语法有两个原因:一个原因是必须这么做,另一个原因是出于效率考虑

初始化列表的必要性 初始化和赋值对内置类型的成员没有什么大的区别,像上面的任一个构造函数都可以。但在一些情况下,初始化列表可以做到构造函数做不到的事情: 1、类里面有const类型的成员,它是不能被赋值的,所以需要在初始化列表里面初始化它; 2、引用类型的成员(也就是名字成员,它作为一个现有名字的别名),也是需要在初始化列表里面初始化的,目的是为了生成了一个其名字成员在类外可以被修改而在内部是只读的对象; 3、需要调用基类的构造函数,且此基类构造函数是有参数的; 4、类里面有其他类类型的成员,且这个“其他类”的构造函数是有参数的。 举个例子:设想你有一个类成员,它本身是一个类或者结构,而且只有一个带一个参数的构造函数。 classCExampleOld { public: CExampleOld(int x) { ... } }; 因为CExampleOld有一个显式声明的构造函数,编译器不产生一个缺省构造函数(不带参数),所以没有一个整数就无法创建CExampleOld的一个实例。 CExampleOld* pEO = new CExampleOld; // 出错!! CExampleOld* pEO = new CExampleOld(2); // OK 如果CExampleOld是另一个类的成员,你怎样初始化它呢?答案是你必须使用成员初始化列表。class CExampleNew { CExampleOldm_EO; public: CExampleNew(); }; // 必须使用初始化列表来初始化成员m_EO //CExampleNew::CExampleNew() : m_EO(2) {……} 没有其它办法将参数传递给m_EO。 情况3和4其实一样的道理。如果成员是一个常量对象或者引用也是一样。根据C++的规则,常量对象和引用不能被赋值,它们只能被初始化。

拷贝构造函数&默认拷贝构造函数&拷贝构造函数调用几种情况

一、拷贝构造函数 如果类中没有说明拷贝构造函数,则系统自动生成一个缺省复制构造函数,作为该类的公有成员 也可以进行自定义拷贝构造函数 自定义拷贝构造函数的例子: Test::Test(const Test& other) : num_(other.num_) { //num_ = other.num_; cout<<"Initializing with other "<

struct初始化及构造函数与class区别

遇到一个bug,debug与release的表现不同。经查是struct结构的默认赋值在debug与release是不同的。实际上包括class及基本类型,未手动初始化的话,在debug与release下是不同的,因为release 的一些优化可能会导致默认赋值时,为随机的内存位置,其值不被重写。居然一直没遇到struct的这个问题,难道我以前都是手动初始化的吗- - 随便把strcut的初始化和默认构造函数等问题查了下。转贴如下。 结构体实例(包括共用体)和类实例的初始化方法完全相同,二者都可以应用于继承层次中。不同点是结构体(包括共用体)默认成员为public,而类默认成员是private型的。 一、若类和结构体所有数据成员均为public型,可采取如下带花括号形式进行初始化。 注意: ①不论值的个数多少,都必须使用花括号定界 ②未指定值的数据成员编译器会自动初始化为默认值 ③这种初始化对象方式,要求所有数据成员必须为public型 ④这种初始化对象方式,要求类中不能编写任何构造函数 struct S { //class S 效果一样 int x; unsigned short y; }; S testS1={100,123}; S testS2={200};//未指定值的数据成员初始化为默认值,这里os2.y=0; S TestS[4]={ {100,10}, {200,20}, {300} };//未指定值的初始化为默认值,os[2].y,os[3].x,os[3].y。 二、若数据成员有private或protected型,或是提供了构造函数,必须使用构造函数来进行初始化。struct S { //class S可自行试验,结果相同 private: int x; public: double y; S(void){} S(int idemo,double ddemo) {x=idemo;y=ddemo;} void show(void) {cout<

构造函数初始化列表

10月11日 C++成员初始化列表(ZZ) c++成员初始化列表 问题 我的问题是关于初始化C++类成员的。我见过许多这样的代码(包括在你的栏目中也见到过):CSomeClass::CSomeClass() { x=0; y=1; } 而在别的什么地方则写成下面的样子: CSomeClass::CSomeClass() : x(0), y(1) { } 我的一些程序员朋友说第二种方法比较好,但他们都不知道为什么是这样。你能告诉我这两种类成员初始化方法的区别吗? 回答 从技术上说,你的程序员朋友是对的,但是在大多数情况下,两者实际上没有区别。有两个原因使得我们选择第二种语法,它被称为成员初始化列表:一个原因是必须的,另一个只是出于效率考虑。 让我们先看一下第一个原因——必要性。设想你有一个类成员,它本身是一个类或者结构,而且只有一个带一个参数的构造函数。 class CMember { public:

CMember(int x) { ... } }; 因为Cmember有一个显式声明的构造函数,编译器不产生一个缺省构造函数(不带参数),所以没有一个整数就无法创建Cmember的一个实例。 CMember* pm = new CMember; // Error!! CMember* pm = new CMember(2); // OK 如果Cmember是另一个类的成员,你怎样初始化它呢?你必须使用成员初始化列表。 class CMyClass { CMember m_member; public: CMyClass(); }; //必须使用成员初始化列表 CMyClass::CMyClass() : m_member(2) { ??? } 没有其它办法将参数传递给m_member,如果成员是一个常量对象或者引用也是一样。根据C++的规则,常量对象和引用不能被赋值,它们只能被初始化。 第二个原因是出于效率考虑,当成员类具有一个缺省的构造函数和一个赋值操作符时。MFC的Cstring提供了一个完美的例子。假定你有一个类CmyClass具有一个Cstring类型的成员m_str,你想把它初始化为"yada yada."。你有两种选择: CMyClass::CMyClass() {

构造函数的继承 C#

基类成员的初始化工作由基类的构造函数完成,派生类的初始化工作则有派生类的构造函数完成,这就产生了派生类构造函数的执行顺序问题,即当创建一个派生类的对象时,如何调用基类和派生类的构造函数分别完成各自成员的初始化。 派生类中的构造函数: 如果基类没有定义构造函数,派生类也可以不定义构造函数,全都采用默认的构造函数,此时,派生类新增成员的初始化工作可用其他公有函数来完成,如果只有派生类定义构造函数时,只需构造派生类对象即可。对象的基类部分使用默认构造函数来自动创建。 基类中的构造函数: 当基类和派生类都定义有构造函数时,情况就变得复杂了,同时也存在着继承规则。 1.如果基类中定义了构造函数,并且此构造函数没有参数,那么他可以隐式的被派生类继承,也就是说,派生类根本不需要包含构造函数,如下例子: namespace Syntaxtest { class Personclass { protected Personclass() { Console.WriteLine("基¨′类¤¨¤中D的ì?构1造¨?函?¥数oy被à?继¨?承D!ê?"); } } class Studentclass : Personclass { } class Program { static void Main(string[] args) { Studentclass t1 = new Studentclass(); } } } 运行结果:在基类中构造函数被继承 从运行结果来看,基类没有参数的构造函数被无条件继承,在派生类中被调用。

2.如果基类定义了带有参数的构造函数,则此构造函数必须被继承且在派生类中实现构造函数,提供一个将参数传递给基类构造函数的途径,以保证在基类进行初始化时能获得必须的数据,在实现构造函数时我们可以使用base关键字。代码如下: namespace Syntaxtest { class Personclass { protected Personclass(string T,string M) { Console.WriteLine("基¨′类¤¨¤中D的ì?构1造¨?函?¥数oy的ì?内¨2容¨Y!ê?"); Console.WriteLine("基¨′类¤¨¤中D的ì?构1造¨?函?¥数oy被à?继¨?承D!ê?"); Console.WriteLine("传??递ìY的ì?参?数oy:{0}",T); Console.WriteLine("传??递ìY的ì?参?数oy:{0}",M); } } class Studentclass : Personclass { public Studentclass(string N, string I):base(N,I) { Console.WriteLine("派¨|生|¨2类¤¨¤中D的ì?构1造¨?函?¥数oy的ì?内¨2容¨Y!ê?"); Console.WriteLine("参?数oy设|¨¨置?的ì?ID是o?:{0}", I); Console.WriteLine("参?数oy设|¨¨置?的ì?姓?名?是o?:{0}", N); } } class Program { static void Main(string[] args) { Studentclass t1 = new Studentclass("xusen","2010"); } } 运行结果: 基¨′类¤¨¤中D的ì?构1造¨?函?¥数oy的ì?内¨2容¨Y!ê? 基¨′类¤¨¤中D的ì?构1造¨?函?¥数oy被à?继¨?承D!ê 传递的参数:xusen 传递的参数:2010 派¨|生|¨2类¤¨¤中D的ì?构1造¨?函?¥数oy的ì?内¨2容¨Y!ê? 参数设置的姓名是:xusen 参数设置的ID是:2010

定义构造函数的四种方法.doc

定义类的构造函数 作者:Iyb661 时间:20150613 定义类的构造函数有如下几种方法: 1、使用默认构造函数(类不另行定义构造两数):能够创建一个类对象,但不能初始化类的各个成员。 2、显式定义带冇参数的构造函数:在类方法中定义,使用多个参数初始化类的各个数据成员。 3、定义有默认值的构造函数:构造函数原型中为类的各个成员捉供默认值。 4、使用构造函数初始化列表:这个构造函数初始化成员的方式显得更紧凑。 例如:有一个学生类。其中存储了学生的姓名、学号和分数。 class Stude nt { private: std::string name; long number; double scores; public: Student(){}//l:default constructor Student(const std::string& najong nu,double sc); Student(const std:;string& na=l,H Jong nu=0,double sc=0.0); Student(const std:;string& na="noong nu=0,double sc=0.0): name( na),nu mber( nu),scores(sc){} void display() const; //void set(std::string najong nu,double sc); }; Student::Student(const std::string& najong nu,double sc) { n ame=na; n umber 二nu; scores=sc; } void Student::display()const { std::cout?H Name: "vvname?,,/ Number: ,,?number?,,/ Score: ,,?scores?,,\n\n”; } 这个学生类极为简单:除了创建和显示学生的姓名、学号、学分以外;什么工作也不做, 什么工作也做不了。 这个类在此处的价值的就是说明类构造函数的工作方式。 1、笫一个构造函数,就是编译器合成的默认构造函数。它用于创建一个类对象而不显式地初始化各个类成员。 Student(){}

1 简述构造函数特点

1 简述构造函数特点 a)没有函数返回值类型 b)必须与本类名完全相同 c)当没有为一个类显示的定义一个构造函数时,系统将自动分配一个默认的无参的方法 体为空的构造函数。如果定义了一个构造函数,那么默认的就没有了。 2 简述构造函数作用:为对象的属性进行初始化赋值。 3 简述this关键字的用法 a)this.成员属性 b)this.成员属性 c)this() 在本类的构造函数中第一条语句调用其他的构造函数 4 举例说明静态代码块和代码块的用法 5 String StringBuilder StringBuffer 的区别 6 String是否有length?有 7 常用的排序方法有哪些? 8 Arrays类与Array类的区别? 9 列举String类中的常用的三个方法?列举StringBuilder类中常用的三个方法? 10 继承的特点是什么? a)子类继承父类所有的成员属性,包括私有属性。 b)但是不继承父类的构造函数。 c)但是会在子类构造函数的第一条语句由JVM默认调用父类的无参的方法体为空的构造函数。 11 解释多态的含义?:同一种事物的不同表现形式。 12 说明private:私有的。默认的:隐藏的。Protected:public:公有的。的用法 13 简述java中的包机制 14 Integer iter1 = 234; Integer iter2 = 234;试问:boolean res = iter1 = = iter2;res的结果为什么? 15 String str = new String(new String(new String(new String(new StringBuilder(“hello”)))));试问一共创建了几个String对象? 16 String str = new String(“你好” ); StringBuilder sb = new StringBuilder(“你好”); boolean res= str.equals(sb);试问上述代码是否有误?如果有请指出并改正? 18 如果父类的某个函数需要被子类重写,那么这个函数不能用哪些关键字修饰? 17 写一个Singleton.

相关文档
最新文档