Java 走向C++

本文不涉及一些微妙蛋疼的语法比较, 关注的是宏观方面, 当然后期逐步更新如果, 如果觉得必要, 可能会加上.

议题之一: 初始化的比较

1．CPP基类的任何类构造函数会默认调用父类的不带参数的构造函数, 这点Java也是同样处理的. 子类调用父类的构造函数方式会不同, C++中这样做:

Son::Son(int id):Father(id) {

//Father(10); //注意，这样虽然编译通过，但事实上在构造一个Father类，完了( 出了作用域)之后就立即销毁. 危害非常之大.

cout<<"in Sonconstructor Son(int id) function!"<<endl;

}

2．Son son 这样的方式初始化, 会将一个对象初始化在栈上, 当超出作用域, 自动消除. Son *son这样的方式初始化, 会将一个对象放在堆上, 需要手动Delete, 否则内存泄漏. Son* pSon这样的方式, 没有构造任何对象.

3．上面也意味着, 除基本类型外, Java的对象都是在堆中分配的.

4．构造和析构的基本顺序是《看源代码》：

view plaincopy to clipboardprint?

1. $./app.exe
2. InMainFunction!
3. inFatherItemconstructorFatherItem()function!
4. infatherconstructorFather(intid)function!
5. inSonItemconstructorSonItem()function!
6. inSonconstructorSon(intid)function!
7. inSondestructor~Son()function!
8. inSonItemdestructor~SonItem()function!
9. inFatherdestructor~Father()function!
10. inFatherItemdestructor~FatherItem()function!

$ ./app.exeIn Main Function!in FatherItem constructor FatherItem()  function!in father constructor Father(int id) function!in SonItem constructor SonItem()  function!in Son constructor Son(int id) function!in Son destructor ~Son() function!in SonItem destructor ~SonItem() function!in Father destructor ~Father() function!in FatherItem destructor ~FatherItem() function!

上面是子类调用父类带参数函数的例子， 基本说明的情况是:

a.父类的成员变量初始化

b.父类的构造函数初始化(看子类调用那个父类的构造函数，默认情况是不带参数的)

c.子类的.h文件中声明的成员变量初始化

d.子类的构造函数调用

析构的顺序正好相反.

这跟Java实质上是一致的, 微弱的区别在于语法表达不同:注意C++引起成员变量的调用, 要么是Son son， 要么是Son* pSon = new Son(); 类似于Son* pSon是没有做初始化的. 不会引起构造函数的调用；而Java中持有的都是引用. 这点需要特别关注, Java中的Son son = new Son()类似于Son* pSon = new Son();(Java中的Son son类似于C++中的Son*pson, 没有做初始化工作). 参见2.

5．关于静态成员变量.

a.Java的静态成员变量在类加载的时候就完成. 类加载是指, 类的首次使用，比如类被构造, 类的其他静态函数或者成员被使用. 因此他会先于所有的成员被初始化. 子类的static成员初始化之前，会先初始化父类的static成员变量, 当静态成员初始化完成之后, 然后参考4的顺序.

b.C++的静态成员变量.

在C++中， 声明静态成员函数是放在.h文件中:

view plaincopy to clipboardprint?

1. public:
2. staticvoidstatic_function();//静态成员函数
3. private:
4. FatherItemitemOne;
5. FatherItemstaticstatic_fatherWithPara;

public:    static void static_function();//静态成员函数private:        FatherItem itemOne;FatherItem static static_fatherWithPara;

将成员变量初始化是放在cpp文件中, 注意跟类定义是类似的:

void Father::static_function() {

// TODO Auto-generated destructor stub

cout<<"in Fatherstatic_function function!"<<endl;

}

FatherItem Father::static_fatherWithPara(10);

当然，结论跟Java是一致的，也即, 类首次加载的时候，完成静态变量的初始化, 加载子类前，首先父类务必先加载. 当类加载成功之后, 在考虑普通变量的初始化，以及构造函数的调用.

6．C++的普通成员初始化.

.h文件中的声明的普通对象被初始化, 比如下面这个:

private:

FatherItem fatherIt;

声明的时候, 先初始化fatherIt, 然后构造函数被调用。跟4的解释一致。但这里就会引申出另外一个问题， 带参数的变量声明，会发生什么, 比如:

private:

FatherItem father(1);

这里要务必注意，这是一个语法错误. 源于声明中存在的二义性问题， 因为我们声明函数也是这么声明的:

private:

ReturnValue FunctionName(Parameter name);

这样编译器看到这个就懵了. 为了清晰起见，我们把这样的声明，还是留给了函数.我们只在头文件中声明变量, 然后在构造函数的外部去定义/初始化这个变量:

在头文件中:

view plaincopy to clipboardprint?

1. private:
2. FatherItemfatherWithPara;

private:    FatherItem fatherWithPara;

在.cpp文件的构造函数中:

view plaincopy to clipboardprint?

1. Father::Father():fatherWithPara(10){
2. cout<<"infatherconstructorFather()function!begin"<<endl;
3. cout<<"infatherconstructorFather()function!end"<<endl;
5. }

Father::Father():fatherWithPara(10) {    cout<<"in father constructor Father() function! begin"<<endl;    cout<<"in father constructor Father() function! end"<<endl; }

这样会带来一个弱点,会发生我们不愿意看到的情况，就是.h中声明的变量，实质上已经被它的默认(即不带参数的)构造函数初始化了, 然后我们在构造函数外部，有对这个变量初始化一次.

——很幸运，这个推断是错误的，结论是: 构造函数外初始化的变量, 在.h中不会被初始化. 也就是说，仅仅初始化一次. 先看我们的测试，马上就可以论证这个结论.

做一个如下的测试，彻底看看对象的初始化过程：

声明两个变量，一个带参数，一个不带参数,这个在头文件中:

view plaincopy to clipboardprint?

1. private:
2. FatherItemitemOne;
3. FatherItemfatherWithPara;

private:    FatherItem itemOne;    FatherItem fatherWithPara;

然后在构造函数中初始化fatherWithPara, 但不初始化itemOne, .cpp的代码如下:

view plaincopy to clipboardprint?

1. Father::Father():fatherWithPara(10){
2. cout<<"infatherconstructorFather()function!begin"<<endl;
3. cout<<"infatherconstructorFather()function!end"<<endl;

    Father::Father():fatherWithPara(10) {    cout<<"in father constructor Father() function! begin"<<endl;    cout<<"in father constructor Father() function! end"<<endl;}

运行代码可以发现，顺序如下:

$ ./app.exe

In Main Function!

in FatherItem constructor FatherItem() function!//头文件的声明产生的调用

in Constructor FatherItem(int i)function! 10 //构造函数外调用

in father constructor Father() function! Begin //构造函数调用

in father constructor Father() function! End

in Father destructor ~Father() function!

in FatherItem destructor ~FatherItem()function!

in FatherItem destructor ~FatherItem()function!

进一步搞定这个问题的方案是: 即使我们.h文件中的变量声明过了, 我们依然在构造函数的外部, 进行再次初始化:

不难发现, .h文件中声明的变量，如果在构造函数外部被初始化了, 则声明中不会再次初始化.

7．有必要总结一下整个初始化，流程，结合4，5和6. 为描述方便, 假如Son son出现在Main函数中, 即son对象需要被初始化:

A.初始化静态变量, 按照先父(Father类)后子(Son类)的顺序:

1.加载静态变量所在的类

2.加载类同时, 立即初始化该类的所有静态成员变量.

B.按照先父(Father类)后子(Son类)的顺序, 完成以下操作, 注意下面是对一个类进行的操作.

1.初始化类的.h文件中声明的变量（并满足在构造函数外没有被初始化）. 调用的是默认构造函数(即不带参数的). 如果在构造函数外出现了成员变量的, .h文件中的变量无需初始化.

2.调用构造函数外所列出的所有成员变量名称涉及的构造方法.

3.调用类的构造函数.

8．有必要约定的规则:

a..h中永远只做声明, 声明了任何变量, 务必在构造函数的外部进行初始化, 即使是不带参数的变量.

b..cpp中永远只做定义.

c.摒弃一切奇技淫巧. 比如今天看到的.h中的声明, 变成定义这样的问题.

附上源码:

源码地址

源码说明:

1. 包含Java和CPP的源代码. 理论上两者都是跨平台的. CPP的是用GCC编译器, 当然用VS肯定是没有问题

2. 主要成员说明: Father类, 持有成员变量FatherItem.

3 Son类, 持有成员变量SonItem

4 Father 和 son是继承关系

5. SonItem和FatherItem没有任何关系.

议题之二: 数据管理

我的个人偏见是，内存管理，实质上是数据管理. 后期展开该话题.

函数参数传递, 全局变量的管理模式, 成员变量的设计思想.

议题之三: 第三方代码的引入或者导出

源码的引入, 比如java会采用import, C++会采用include, using namespace的方式

二进制代码模块的引入, java会引入jar包. C++会引入静态库, 共享库/动态库等.

http://blog.csdn.net/ostrichmyself/article/details/6035538