C++ VS C#（8）：类定义
//=====================================================================
//TITLE:
// C++ VS C#（8）：类定义
//AUTHOR:
// norains
//DATE:
// Thursday 17-January-2011
//Environment:
// Visual Studio 2010
// Visual Studio 2005
//=====================================================================1. 类定义
C++和C#都具备面向对象的特性，自然而然，两者都有类这个玩意。无论是C++，或是C#，定义类的关键字都是class。也就是说，这两种语言都可以这样声明一个类：
view plaincopy to clipboardprint?
class CMyClass
{
//Class members
};
class CMyClass
{
//Class members
};
至此，C++的声明就是如此了。但C#还在此基础上再度发展，在class之前还有internal和public两个关键字可选。默认的情况下，类声明是内部的，只有当前项目的代码才能访问它，换句话来说，上面的声明在C#中相当于如此：
view plaincopy to clipboardprint?
internal class CMyClass
{
//Class members
};
internal class CMyClass
{
//Class members
};
如果想在别的项目中也能使用该代码，那么必须用public来进行修饰，如：
view plaincopy to clipboardprint?
public class CMyClass
{
//Class members
};
public class CMyClass
{
//Class members
};
除了这两个访问修饰以外，还能指定类是否是抽象的，或密封的。抽象的关键字是abstract，表明其不能实例化，只能继承；密封的关键字是sealed，表示其不能被继承。从意思上我们就可以知道，这两个关键字是互斥的，两者只能选择其一。
如果我们声明一个抽象的公共类，代码可以书写如下：
view plaincopy to clipboardprint?
public abstract class CmyClass
{
//Class members
}
public abstract class CmyClass
{
//Class members
}
public和abstract这两个关键字的次序无关紧要，可以随意颠倒。
我们来讨论一个很有意思的问题，C++没有这两个关键字，是不是就没办法实现类似于C#的功能了呢？答案当然不是了。我们来看看，如何用C++来实现C#的这两个特性。
首先来看的是密封，也就是不能让这个类被继承。虽然C++没有sealed关键字，但实现这个功能一点也不费功夫，我们只要将构造函数或析构函数声明为private即可，如下代码所示：
view plaincopy to clipboardprint?
//父类
class CMyBase
{
//将构造函数和析构函数声明为private
private:
CMyBase(){};
virtual ~CMyBase(){};
};
//子类
class CMyClass:
public CMyBase
{
public:
CMyClass(){};
virtual ~CMyClass(){};
};
//这个声明编译时会出错
CMyClass ab;
//父类
class CMyBase
{
//将构造函数和析构函数声明为private
private:
CMyBase(){};
virtual ~CMyBase(){};
};
//子类
class CMyClass:
public CMyBase
{
public:
CMyClass(){};
virtual ~CMyClass(){};
};
//这个声明编译时会出错
CMyClass ab;
当CMyClass继承于CmyBase，并且声明一个CmyClass对象时，那么编译器就会报如下错误：
error C2248: CMyBase::CMyBase : cannot access private member declared in class CMyBase
error C2248: CMyBase::~CMyBase : cannot access private member declared in class CMyBase
通过将构造函数和析构函数声明为private的方式，就达到了让类无法被继承的目的。
接着来看看抽象，也就是类不能实例化，只能进行继承。这个C++也能够实现，但却并不是很完美。我们都知道，C++的类什么情况下不能实例化？就是类中带有纯虚函数的时候。借助这个特性，我们也能实现类不能实例化的目的，如下代码所示：
view plaincopy to clipboardprint?
class CMyBase
{
public:
CMyBase(){};
virtual ~CMyBase(){};
protected:
//定义一个纯虚函数，令该类不能实例化
virtual void Abstract() = 0;
};
class CMyClass:
public CMyBase
{
public:
CMyClass(){};
virtual ~CMyClass(){};
protected:
//必须要实现纯虚函数，否则本类也不能实例化
virtual void Abstract(){};
};
//有纯虚函数，该声明有错
CMyBase MyBase;
//该声明正确通过
CMyClass MyClass;
class CMyBase
{
public:
CMyBase(){};
virtual ~CMyBase(){};
protected:
//定义一个纯虚函数，令该类不能实例化
virtual void Abstract() = 0;
};
class CMyClass:
public CMyBase
{
public:
CMyClass(){};
virtual ~CMyClass(){};
protected:
//必须要实现纯虚函数，否则本类也不能实例化
virtual void Abstract(){};
};
//有纯虚函数，该声明有错
CMyBase MyBase;
//该声明正确通过
CMyClass MyClass;
虽然我们通过了纯虚函数实现了类不能实例化的目的，但同时却也带出了纯虚函数这个累赘，令子类为了实例化不得不实现这个没有任何意义的纯虚函数。相对而言，在这个方面，C#确实比C++要简便很多。
补充：软件开发 , C++ ,
