Chinaunix首页 | 论坛 | 博客

红碑山屌丝的学习园地

首页　| 　博文目录　| 　关于我

coolzsj

  • 博客访问： 289132
  • 博文数量： 111
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 816
  • 用 户 组： 普通用户
  • 注册时间： 2014-05-04 20:35
文章分类

全部博文（111）

文章存档

2016年（1）

2015年（5）

2014年（105）

我的朋友
最近访客
推荐博文
相关博文
C++成员变量、构造函数的初始化顺序

分类： C/C++

2014-06-20 07:58:48

一、C++成员变量初始化

1、普通的变量：一般不考虑啥效率的情况下 可以在构造函数中进行赋值。考虑一下效率的可以再构造函数的初始化列表中进行

2、static 静态变量(本地化数据和代码范围)：

static变量属于类所有，而不属于类的对象，因此不管类被实例化了多少个对象，该变量都只有一个。在这种性质上理解，有点类似于全局变量的唯一性。


  • 函数体内static变量的作用范围时该函数体，不同于auto变量，该变量内存只被分配一次，因此其值在下次调用时维持上次的值。
  • 在模块内的static全局变量可以被模块内所有函数访问，但不能被模块外的其它函数访问。
  • 在模块内的static函数只可被这一模块内的其他函数调用，这个函数的适用范围被限制在声明它的模块内。
  • 在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝。
  • 在类中的static成员函数属于整个类所拥有，这个函数不接受this指针，因而只能访问类的static成员变量。

3、const 常量变量：

const常量需要在声明的时候即初始化。因此需要在变量创建的时候进行初始化。一般采用在构造函数的初始化列表中进行。

4、Reference 引用型变量：

引用型变量和const变量类似。需要在创建的时候即进行初始化。也是在初始化列表中进行。但需要注意用Reference类型。

4、字符串初始化

char str[10] = "HELLO";

结尾会被编译器自动加上结尾符'/0',编译的时候可以看到它最后是'',ASC码值是0;

"HELLO"只有5个字符,加上编译器自动添加的'/0',也就是会初始化数组的前6个元素,剩下有元素会被全部初始化为'/0',这个要注意哦

char str[] = "HELLO";

编译器自动为后面的字符串分配大小并加'/0'

char str[] = {'H','E','L','L','O','/0'};

编译器会根据字符串大小分配空间,可是不会自动分配'/0',所以结尾的时候要自己加上'/0'

char *str = "HELLO";

把指向字符串的指针给定义好的字符指针

1）用构造函数确保初始化

对于一个空类，编译器会自动声明4个默认函数：构造函数、拷贝构造函数、赋值函数、析构函数（如果不想使用自动生成，就应该明确拒绝），这些生成的函数都是public且inline的。

2）为什么构造函数不能有返回值

3）为什么构造函数不能为虚函数

虚函数调用的机制，是知道接口而不知道其准确对象类型的函数，但是创建一个对象，必须知道对象的准确类型；当一个构造函数被调用时，它做的首要事情之一就是初始化它的VPTR来指向VTABLE。

面试题：构造函数

view source
print?
01 #include
02 using namespace std;
03
04 class Base
05 {
06 private:
07 int i;
08 public:
09 Base(int x)
10 {
11 i = x;
12 }
13 };
14
15 class Derived : public Base
16 {
17 private:
18 int i;
19 public:
20 Derived(int x, int y)
21 {
22 i = x;
23 }
24 void print()
25 {
26 cout << i + Base::i << endl;
27 }
28 };
29
30 int main()
31 {
32 Derived A(2,3);
33 A.print();
34 return 0;
35 }
首先，是访问权限问题，子类中直接访问Base::i是不允许的，应该将父类的改为protected或者public（最好用protected）

其次，统计父类和子类i的和，但是通过子类构造函数没有对父类变量进行初始化；此处编译会找不到构造函数，因为子类调用构造函数会先找父类构造函数，但是没有2个参数的，所以可以在初始化列表中调用父类构造函数

最后个问题，是单参数的构造函数，可能存在隐式转换的问题，因为单参数构造函数，和拷贝构造函数形式类似，调用时很可能会发生隐式转换，应加上explicit关键字

view source
print?
01 #include
02 using namespace std;
03
04 class Base
05 {
06 protected:
07 int i;
08 public:
09 explicit Base(int x)
10 {
11 i = x;
12 }
13 };
14
15 class Derived : public Base
16 {
17 private:
18 int i;
19 public:
20 Derived(int x, int y):Base(x)
21 {
22 i = y;
23 }
24 void print()
25 {
26 cout << i + Base::i << endl;
27 }
28 };
29
30 int main()
31 {
32 Derived A(2,3);
33 A.print();
34 return 0;
35 }

2、初始化列表

1）使用初始化列表提高效率

view source
print?
01 class Student
02 {
03 public:
04 Student(string in_name, int in_age)
05 {
06 name = in_name;
07 age = in_age;
08 }
09 private :
10 string name;
11 int age;
12 };

因为在构造函数中，是对name进行赋值，不是初始化，而string对象会先调用它的默认构造函数，再调用string类（貌似是basic_string类）的赋值构造函数；对于上例的age，因为int是内置类型，应该是赋值的时候获得了初值。

要对成员进行初始化，而不是赋值，可以采用初始化列表（member initialization list）

view source
print?
1 class Student
2 {
3 public:
4 Student(string in_name, int in_age):name(in_name),age(in_age) {}
5 private :
6 string name;
7 int age;
8 };

在初始化的时候调用的是string的拷贝构造函数，而上例会调用两次构造函数，从性能上会有不小提升

有的情况下，是必须使用初始化列表进行初始化的：const对象、引用对象

2）初始化列表初始顺序

view source
print?
01 #include
02 using namespace std;
03
04 class Base
05 {
06 public:
07 Base(int i) : m_j(i), m_i(m_j) {}
08 Base() : m_j(0), m_i(m_j) {}
09 int get_i() const
10 {
11 return m_i;
12 }
13 int get_j() const
14 {
15 return m_j;
16 }
17
18 private:
19 int m_i;
20 int m_j;
21
22 };
23
24 int main()
25 {
26 Base obj(98);
27 cout << obj.get_i() << endl << obj.get_j() << endl;
28 return 0;
29 }
输出为一个随机数和98，为什么呢？因为对于初始化列表而言，对成员变量的初始化，是严格按照声明次序，而不是在初始化列表中的顺序进行初始化，如果改为赋值初始化则不会出现这个问题，当然，为了使用初始化列表，还是严格注意声明顺序吧，比如先声明数组大小，再声明数组这样。


C++构造函数初始化按下列顺序被调用：


  • 首先，任何虚拟基类的构造函数按照它们被继承的顺序构造；
  • 其次，任何非虚拟基类的构造函数按照它们被继承的顺序构造；
  • 最后，任何成员对象的构造函数按照它们声明的顺序调用；


view source
print?
01 #include
02 using namespace std;
03 class OBJ1{
04 public:
05 OBJ1(){ cout<<"OBJ1\n"; }
06 };
07 class OBJ2{
08 public:
09 OBJ2(){ cout<<"OBJ2\n";}
10 }
11 class Base1{
12 public:
13 Base1(){ cout<<"Base1\n";}
14 }
15 class Base2{
16 public:
17 Base2(){ cout <<"Base2\n"; }
18 };
19 class Base3{
20 public:
21 Base3(){ cout <<"Base3\n"; }
22 };
23 class Base4{
24 public:
25 Base4(){ cout <<"Base4\n"; }
26 };
27 class Derived :public Base1, virtual public Base2,public Base3, virtual public Base4//继承顺序{
28 public:
29 Derived() :Base4(), Base3(), Base2(),Base1(), obj2(), obj1(){//初始化列表
30 cout <<"Derived ok.\n";
31 }
32 protected:
33 OBJ1 obj1;//声明顺序
34 OBJ2 obj2;
35 };
36
37 int main()
38 {
39 Derived aa;//初始化
40 cout <<"This is ok.\n";
41 return 0;
42 }
43 结果：
44 Base2 //虚拟基类按照被继承顺序初始化
45 Base4 //虚拟基类按照被继承的顺序
46 Base1 //非虚拟基类按照被继承的顺序初始化
47 Base3 //非虚拟基类按照被继承的顺序
48 OBJ1 //成员函数按照声明的顺序初始化
49 OBJ2 //成员函数按照声明的顺序
50 Derived ok.
51 This is ok.
阅读(527) | 评论(0) | 转发(0) |
0

上一篇：C++基本功能

下一篇：C++运算符重载，继承，模板，异常

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6