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

全部博文(111)

文章存档

2016年(1)

2015年(5)

2014年(105)

我的朋友

分类: C/C++

2014-06-22 09:05:33

一、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。

面试题:构造函数

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关键字

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)使用初始化列表提高效率

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)

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)初始化列表初始顺序

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++构造函数初始化按下列顺序被调用:


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


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{
阅读(538) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
16 public: