浅谈C++类 - 概念和构造函数

虽然学习了一段时间的C++了，可是针对一些难以理解的东西，我还是习惯于梳理记录下来，一方面是自己知识的一种条理化，另一方面是能够帮助到需要的人。

类是C++中的重中之重，几乎在C++的每一本书里面都会有很大的篇幅来讲解类。那么究竟什么是类？对于有C基础的人来说，一看概念就基本了解了，可是真正的类的理解却还要下一番功夫的。C++提供了很好的STL，因此我们在学习类的时候可以有更大的函数库和代码可以使用。

首先，我们来看一下概念。很多C++教科书上都是这样讲的：类是具体对象（实例）的抽象。那么究竟如何抽象？就是把一个实例的特征提取出来，比如，水果是一个类，苹果是水果的一个实例，苹果有苹果的特征，其他水果有其他水果的特征，比如香蕉。我们只要从苹果香蕉中把特征提取出来进行统一管理就可以，这样就形成了水果类class Fruits()。然后“Fruites apple”，表示苹果是水果的一个实例。就像人如果是一个类的话，我们每一个人都是这个类的实例。Bjarne Stroustup来自于Simula的概念（The Design and Evolution of C++)，一个class其实就是一个用户定义的新的Type，这点和结构体（struct）没有本质上的区别，只是使用上的区别而已。

概念就是概念，看完之后没有太多的印象，我们只有在概念的基础上编程、编程、再编程才是最快的。

1、一个简单的类

C++中使用任何东西都是要先定义的，类也一样，我们要在使用类的之前对类进行定义。我们以水果为例：

#include<string>
#include<iostream>
#include<conio.h>

usingnamespacestd;

classFruit//定义一个类，类的名字是Fruit
{
public:stringname;
};

intmain()
{
Fruitapple={"apple"};//定义一个Fruit的类对象apple
cout<<apple.name<<endl;//使用apple的数据成员name
_getch();
return0;
}

程序的说明就省略了.不过要提的一点是，类中不仅可以有数据成员，也可以有函数成员。另外类的默认标号是private类型的。

例如将上边程序稍作修改：

#include　<string>
#include　<iostream>
using　namespace　std;

class　Fruit　　　　　　　//定义一个类，名字叫Fruit
{
public:　　//标号，表示这个类成员可以在外部访问

string　name;　　　　//定义一个name成员
void　print()　　　　　//定义一个输出名字的成员print()
{
cout  <<　name  <<  endl;
}
};

int　main()
{
Fruit　apple　=　{"apple"};　　//定义一个Fruit类对象apple
apple.print();　　//使用apple的成员print
return　0;
}

可以发现与C的不同了，你可以在class中添加成员函数，让C++有了面向对象的特征，而C是结构化的编程。另外C++类中还有一个构造函数的概念。先看例子：

#include　<string>
#include　<iostream>

using　namespace　std;

class　Fruit　　　　　//定义一个类，名字叫Fruit
{
public:　　　　　　//标号，表示这个类成员可以在外部访问
string　name;　　　//定义一个name成员
void　print()　　　　　//定义一个输出名字的成员print()
{
cout  <<　name  <<  endl;
}
Fruit(const　string　&st)　//定义一个函数名等于类名的函数成员
{
name　=　st;
}
};

int　main()
{
Fruit　apple　=　Fruit("apple");　　//定义一个Fruit类对象apple
Fruit　apple　=　Fruit("orange");
apple.print();　　//使用apple的成员print
orange.print();
return　0;
}

例子中的函数名就等于类名的函数成员，就是构造函数，在每一次定义一个新的对象时，程序自动调用。程序中我们定义了两个对象，一个apple，一个orange，分别用了两种不同的方法，你会发现构造函数的作用。另外对象只能等于对象，不能等于某个字符串等等。此时就不能直接Fruit bananer了，因为已经没有可用的构造函数了，而没有构造函数之前，可以这样做：直接Fruit banner，在使banner.name = “banner”;

#include　<string>
#include　<iostream>

using　namespace　std;

class　Fruit　　　　　//定义一个类，名字叫Fruit
{
public:　　　　//标号，表示这个类成员可以在外部访问
string　name;　　　　　　　　　　　　//定义一个name成员
void　print()　　　　//定义一个输出名字的成员print()
{
cout  <<  name  <<  endl;
}
};

int　main()
{
Fruit　apple;　　//定义一个Fruit类对象apple
apple.name　="apple";　　//这时候才初始化apple的成员name
apple.print();　　//使用apple的成员print
return　0;}

而有了构造函数之后就不能这样做了，有两种方法可以实现：第一种，就是重载一个空的构造函数。那么什么是重载呢？我们看一个例子：

#include　<string>
#include　<iostream>

using　namespace　std;
class　Fruit　　　　　　//定义一个类，名字叫Fruit
{
public:　　　　　　//标号，表示这个类成员可以在外部访问
string　name;　　　　//定义一个name成员
void　print()　　　　　//定义一个输出名字的成员print()
　{
cout  <<　name<<endl;
}
Fruit(const　string　&st)
{　　name　=　st;
}
Fruit(){}　　　　//重载一个空构造函数
};

int　main()
{
Fruit　apple;　　//定义一个Fruit类对象apple,这时是允许的了，自动调用第2个构造函数
apple.name　="apple";　　//这时候才初始化apple的成员name
apple.print();　　//使用apple的成员print
return　0;}

第二种方法就是使用构造函数默认实参：

<span style="font-family: Microsoft YaHei;">#include　<string> 
#include　<iostream> 
using　namespace　std; 
class　Fruit　　　　　　　　　　　　　　　//定义一个类，名字叫Fruit 
{ 
public:　　　　　　　　　　　　　　　　//标号，表示这个类成员可以在外部访问　</span>

<span style="font-family: Microsoft YaHei;">string　name;　　　　　　　　　　　　//定义一个name成员　　　　　　　　　</span>

<span style="font-family: Microsoft YaHei;">void　print()　　　　　　　　　　　　　　//定义一个输出名字的成员print() 　
{ 　　
cout  <<　name<<endl; 　
} 　

Fruit(const　string　&st　=　"banana") 　
{ 　　
name　=　st; 　
} 
}; 

int　main() 
{ 　
Fruit　apple;　　//定义一个Fruit类对象apple 　
apple.print(); 　
apple.name　="apple";　　//这时候才初始化apple的成员name 　
apple.print();　　//使用apple的成员print 　　　
return　0;
 }

</span>

程序中当直接定义一个屋初始值的apple的时候，它就把name表示为banana。前面讲过，不推荐使用Fruit apple = { “apple”}，在这里可以看到原因，因为这样的初始化，必须保证成员可以被访问，当name为私有成员的时候，这样就不奏效了。当牵扯到类的数据封装的时候，就不能这样进行对象的实例化了。

构造函数的操作见下例：

<span style="font-family: Microsoft YaHei;">#include　<string> 

#include　<iostream>
 using　namespace　std;

 class　Fruit　　　　　　　　　　　　　　　//定义一个类，名字叫Fruit
 { 　　　　　　//没有标号了，表示这个类成员不可以在外部访问，class默认为private
string　name;　　　　　　　　　　　　//定义一个name私有成员　　　　　　　</span>

<span style="font-family: Microsoft YaHei;">public:　　　
void　print()　　　　　　　　　　　　　　//定义一个输出名字的成员print() 　
{ 　　
cout <<　name<<endl; 　
} 　

Fruit(const　string　&st　=　"banana") 　
{ 　　
name　=　st; 　
} 
};

 int　main() 
{ 　
Fruit　banana;　　//定义一个Fruit类对象　</span>

<span style="font-family: Microsoft YaHei;">banana.print(); 　
banana.name　="apple";　　//这时候才改变banana的成员name已经是不允许的了 
//　　你要定义一个name等于apple的成员必须这样：　
Fruit　apple("apple"); 　
apple.print(); 　　　
return　0; 
}

要说明的是，构造函数必须定义更公用的，因为必须要在外部调用。关于构造函数还有一些特殊的形式，初始化列表。

#include　<string> 
#include　<iostream> 
using　namespace　std; 
class　Fruit　　　　　　　　　　　　　　　//定义一个类，名字叫Fruit
 { 　　
string　name;　　　　　　　　　　　　//定义一个name成员　　　　　　　　　　</span>

<span style="font-family: Microsoft YaHei;"> public:　　　
void　print()　　　　　　　　　　　　　　//定义一个输出名字的成员print() 　
{ 　　
cout<<　name<<endl; 　
} 　
Fruit(const　string　&st　=　"banana"):name(st){}　　//看到不同了吗？ 
}; 

int　main() 
{ 　
Fruit　banana;　　//定义一个Fruit类对象　banana.print(); 　　　
return　0; 
}

</span>

在参数表后，函数实体前，以“：”开头，列出的一个列表，叫初始化列表，这里初始化列表的作用和以前的例子完全一样，就是用st初始化name，问题是，为什么要特别定义这个东西呢？C++ Primer的作者Lippman在书里面声称这时许多相当有经验的C++程序员都没有掌握的一个特性，因为很多时候根本就不需要，用我们以前的形式就够了但有种情况是例外。在说明前我们为我们的Fruit加个固定新成员，而且定义后不希望再改变了，比如颜色。

<span style="font-family: Microsoft YaHei;">#include　<string>
 #include　<iostream>

 using　namespace　std; 

class　Fruit　　　　　　　　　　　　　　　//定义一个类，名字叫Fruit
 { 　　
string　name;　　　　　//定义一个name成员　　　　　　　　　　　
const　string　colour; 
public:　　　
void　print()　　　　　　　　　　　　　　//定义一个输出名字的成员print() 　
{ 　　
cout  <<colour  <<"　"  <<name  <<endl; 　
} 　
Fruit(const　string　&nst　=　"apple",const　string　&cst　=　"green"):name(nst),colour(cst){}　 
}; 

int　main() 
{ 　
Fruit　apple;　　//定义一个Fruit类对象apple 　
apple.print(); 　　　
return　0; 
}

</span>

在这里吧colour的初始化放在{}里，用以前的方法会有报错，因为她是const的，而实际上放在{}里面的是个计算阶段，而放在初始化列表里面就可以，因为初始化列表的使用时在数据定义的时候就自动调用了。因为这个原因，数据的调用顺序和初始化列表里面的顺序无关，只和数据定义的顺序有关。

给两个例子，比如你在上面的例子中把初始化列表改为":colour(name),name(nst)"没有任何问题，因为在定义 colour前面，name 就已经定义了，但是":name(colour),colour(cst)"却不行，因为在name定义的时候colour 还没有被定义，而且问题的严重性在于我可以通过编译.........太严重了，所以在C++ Primer不推荐你使用数据成员初始化另外一个数据，有需要的话，可以":name(cst),colour(cst)"，一样的效果。另外，初始化列表在定义时就自动调用了，所以在构造函数{}之前使用，你可以看看这个例子：

#include　<string>
#include　<iostream>

using　namespace　std;
class　Fruit　　　　　　　　　//定义一个类，名字叫Fruit
{
string　name;　　　　　//定义一个name成员　　　　　　　　　　　const　string　colour;
public:
void　print()　　　　　　//定义一个输出名字的成员print()
{　　cout<<colour<<"　"<<name<<endl;　}
Fruit(const　string　&nst　=　"apple",const　string　&cst　=　"green"):name(nst),colour(cst)
{
name　+="s";　　　　//这时name已经等于"apple“了
}
};

int　main()
{
Fruit　apple("apple","red");　　//定义一个Fruit类对象apple　apple.print();
return　0;
}

最后输出 red apples。

好了，针对构造函数做了一点点的总结归纳，知识还不是那么有条理性，很多地方还不是很完善，敬请指正！