[转]C++ 关于类的那些基础事

作者: wudemiao专栏 ,发布于2012-4-10

（一）类的const成员函数与重载

1、看看下面的代码，定义了一个dispaly()和重载了一个display()；我们现在聊聊const函数成员和，const重载。我们知道将函数成员的后面加上const是定义一个const函数成员。那么const函数成员有什么特性呢？

很简单就是不能改变其所操作的数据成员。其实还有一个作用哦，就是实现重载函数。需要注意的是在display()重载成员函数并不是前面的cosnt在起着作用哦，因为我们是不能依靠返回值的类型不同来实现函数的重载的。这条想必大家都是知道的。

#include

using namespace std;

class Screen{

private:

void do_display() const

{

cout<<"OK!!!"<<endl;

}

public:

Screen &display()

{

cout<<"Not const."<<endl;

do_display();

return *this;

}

const Screen &display()const

{

cout<<"Const."<<endl;

do_display();

return *this;

}

};

int main()

{

Screen screen;

screen.display();

const Screen screen1;

screen1.display();

return 0;

}

不信你可以试试，将后面的const去掉改成下面这样：

const Screen &display()

{

cout<<"Const."<<endl;

do_display();

return *this;

}

编译器将会报错告诉你无法重载仅按返回值类型重载的函数。还有一点需要注意的就是const成员必须在定义和声明中都出现哦。

2、注意区分返回*this中的this是一个指向类类型的const指针和指向const类类型的const的指针

指向类类型的const指针是指可以改变this所指向的值，但是不能改变this所保存的地址。而指向const类类型的const的指针，既不能改变this所指向的地址，也不能改变所指向的对象。或许你还是不明白吧。其实this可定是指向一个地址，这是没有什么质疑的吧。const指针也就是说这个地址是const的，所以this所指向的地址是不可变。也就是说，无论你现在所向的对象是谁？但是总是存放在这块内存中。而const类类型的对象，显然就是说对象是const的，对象的是不能改变的，自然对象里面的值也是不能改变的。那么指向const类类型的const指针就是指向某一固定的内存的某一固定的对象，地址和对象都不能改变。

上面的例子中开始的函数返回的是指向类类型的const指针，重载的函数display()则返回的是指向const类类型的const的指针。后者是不能在改变所指向的对象的。

（二）返回值类型不一定在类的作用域中

观察线面代码：

class A{

public:

typedef string::size_type type;

type getCur() const;

private:

type cur;

};

type A::getCur() const

{

return cur;

}

我们知道typedef的几个基本用处：

（1）隐藏特定的类型实现，强调使用类型的目的。

（2）简化复杂的类型的定义，使其更易理解。

（3）允许一种类型多种用途。

我们在此处使用的就是（2）简化复杂类型的定义。对于（3）的应用，学过windows程序设计的人，应该不陌生。（1）的应用估计大家用的都比较多吧！

很明显的是你会编译不通过，因为type是一个在类里面定义的类型。在定义体之外定义就要注意了哦；要改成

A::typeA::getCur() const

关于构造函数

关于构造函数，大家应该都十分熟悉了吧，几天和大家一起看看一些需要注意的地方。

1、必须注意的是有些成员必须用初始化列表实现初始化。

（1）没有构造函数的类类型成员。

（2）const成员或引用类型成员

首先解释一下（2）吧。我们知道对于const和引用类型的对象是只能初始化而不能做对他们赋值的。所以自然就只能用初始化列表了哦。

对于（1）的解释，看看下面的代码吧。

#include

using namespace std;

class A{

private:

int cur;

public:

A(int cur)

{

this->cur = cur;

}

};

//A没有默认的构造函数，所以在B的默认构造函数中，只能用初始化列表来实现

class B{

private:

A a;

public:

B():a(10)

{

}

};

想想你如果不是用的初始化列表，那么你可就没有办法初始化咯！！！所以类总是声明和定义默认构造函数是个不错的选择。

2、默认构造函数，你只要记住下面这句话就OK了。

如果一个类哪怕只定义了一个构造函数编译器在也不会生成默认构造函数。

关于默认构造函数可以参看下面这篇博文：C/C++--C++默认参数及其所引起的二义性

（三）隐式类类型转换

看看下面的代码吧：

#include

#include

using namespace std;

class Same{

private:

string isbn;

public:

Same(const string &book = ""):isbn(book)

{

cout<<"Same() is run!!!"<<endl;

}

bool is_same(const Same s1)

{

return isbn>s1.isbn;

}

};

// 应该用explict消除这种，隐式的类型转换。而用显示的类型转换；

//以免产生语义上的错误.

int main()

{

string nullBook = "Head First";

Same same;

cout<<(same.is_same(nullBook)? "True":"False")<<endl;

return 0;

}

注意在is_same(constSame s1);调用的时候就有一个隐式的类型转换，直接将string隐式的通过调用构造函数，生成了一个临时的Same对象。运行你会发现，Same()调用了两次哦。

不过这可不是什么好习惯哦。对于这样的隐式类型转换有时候是让人匪夷所思的。所以最好就是使用explict声明，使其不会产生隐式类型的转换。而是用现实的构造函数的调用来实现：same.is_same(Same(bullBook))这样意图就很明显了吧。

转载于:https://www.cnblogs.com/mr-totoro/archive/2012/12/05/5785716.html