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

最新推荐文章于 2024-03-23 10:54:18 发布

weixin_34248849

最新推荐文章于 2024-03-23 10:54:18 发布

阅读量92

点赞数

文章标签： c/c++

原文链接：http://blog.51cto.com/zyczl/773555

版权

虽然学习了一段时间的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>

using namespace std;

class Fruit //定义一个类，类的名字是Fruit
{
public: string name;
};

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

程序的说明就省略了.不过要提的一点是，类中不仅可以有数据成员，也可以有函数成员。另外类的默认标号是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; }

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

#include　<string> #include　<iostream> using　namespace　std; class　Fruit　　　　　　　　　　　　　　　//定义一个类，名字叫Fruit { public:　　　　　　　　　　　　　　　　//标号，表示这个类成员可以在外部访问　string　name;　　　　　　　　　　　　//定义一个name成员　　　　　　　　　　　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; }

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

构造函数的操作见下例：

#include　<string> #include　<iostream> using　namespace　std; class　Fruit　　　　　　　　　　　　　　　//定义一个类，名字叫Fruit { 　　　　　　　　　　　　　　　//没有标号了，表示这个类成员不可以在外部访问，class默认为private哦　string　name;　　　　　　　　　　　　//定义一个name私有成员　　　　　　　　　　 public:　　　void　print()　　　　　　　　　　　　　　//定义一个输出名字的成员print() 　{ 　　cout<<　name<<endl; 　} 　Fruit(const　string　&st　=　"banana") 　{ 　　name　=　st; 　} }; int　main() { 　Fruit　banana;　　//定义一个Fruit类对象　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成员　　　　　　　　　　 public:　　　void　print()　　　　　　　　　　　　　　//定义一个输出名字的成员print() 　{ 　　cout<<　name<<endl; 　} 　Fruit(const　string　&st　=　"banana"):name(st){}　　//看到不同了吗？ }; int　main() { 　Fruit　banana;　　//定义一个Fruit类对象　banana.print(); 　　　return　0; }

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

#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; }

在这里吧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;
}