effecitve c++ 条款26 -30

effective c++的下载地址http://download.csdn.net/detail/mlkiller/5335383

大家可能觉得文章写得有点虎头蛇尾的，前面几章写得比较详细，而后面的似乎就简略了很多。

两个原因吧，第一是，激情确实比之前少一些，第二个，能力问题，前面的情况大多遇到过，后面熟悉程度不够。

不管怎么样先坚持写完，以后有感触，或者知道有些问题的重要性，遇到类似问题，在进行补充。

条款二十六：当心潜在二义性。

这个条款，我确实没有遇到过，但是看作者的描述，知道什么意思。

c/c++中有隐性转换，所以在函数调用的时候，如果形参和实参类型不匹配，编译器会试着将形参转换为实参，如果不能转换再去报错。

虽然有二义性，但是这个时候编译会报错，编译报错远远好于运行的时候出问题。

书上的例子

class B;
// 对类B提前声明

class A {
public:
A(const B&); // 可以从B构造而来的类A
};
class B {
public:
operator A() const; // 可以从A转换而来的类B
};


void f(int)
{
}
void f(char)
{
}
void f(const A&)
{
}
int main()
{
	double d = 6.02;
	f(d);
	B b;
	f(b);
}

26ambiguity.cpp: 在函数‘int main()’中:
26ambiguity.cpp:26:5: 错误：调用重载的‘f(double&)’有歧义
26ambiguity.cpp:14:6: 附注：备选为： void f(int)
26ambiguity.cpp:17:6: 附注：         void f(char)

还有一些二义性，比较麻烦，由于改变访问权限，导致掉错了函数，这样编译器也检查不出来错误。

例如A有个public do(), B有个private do() ，c继承A,B，如果有人把A的do，修改为protected,把B的do修改为public，就会导致原先的代码出问题。

所以最好使用单继承，另外修改访问权限，需要注意。

条款27: 如果不想使用隐式生成的函数就要显式地禁止它

这个是什么原因呢？

就是你声明一个类例如

class A

{

}

什么都不做，

会自动生成A的拷贝构造函数A(const A&)和赋值构造函数 A operator=(const A&)，做的操作是按位进行赋值。

有的时候，你可能不需要这赋值构造函数和拷贝构造函数，或者他们能带来问题，那么你就需要将他们明令禁止掉。

把它定义为private的，并且只声明，不定义，这样即使别人误用了，编译也会报错。

条款28: 划分全局名字空间

这个条款在大型项目中十分的有用。

例如一些const类型的变量，可能在模块A中，它的值是10,在模块B中，它的值是5,但是两个模块还都想用同一个名字去表示，简单易懂。

这个时候，利用名字空间就很好了，namespace

namespace A_module
{
       const   int priceFactor = 1;
}


namespace B_module
{
       const   int priceFactor = 1;
}

那么怎么使用呢？

以A中的为例子有下面三种调用方法：

int main()
{
	
	{
		using namespace A_module;
		cout<<priceFactor<<endl;
	}
	{
		using A_module::priceFactor;
		cout<<priceFactor<<endl;
	}
	{
		cout<<A_module::priceFactor<<endl;
	}

}

namespace其实就是一个前缀的功能，这样写可以让程序简单易懂。

条款29: 避免返回内部数据的句柄

这一句话把握搞蒙了，句柄不是windows里面才有的，怎么在这里说。

这里不是特别理解这个句柄的意思，姑且还按照指针，或者指向指针的指针去理解。

有两种情况，第一个是类是const类型的，不希望外部的操作改变类的内部数据，书上的例子：

很多例子，建议读者自己去敲一遍，这样才能记忆深刻。

#include <iostream>
#include <cstring>
using namespace std;
class mystring{
public:
	mystring(const char *value);
	~mystring();
	
	operator char*() const;

private:
	char *data;
};

mystring::mystring(const char  *value)
{
	data = new char[strlen(value)+1];
	strcpy(data,value);
}
mystring::~mystring()
{
    delete []data;
}
mystring::operator char*()const
{
	return data;
}
int main()
{
	const mystring b("hello world");
	char *str = b;
	strcpy(str, "hi mom");

	cout<<str<<endl;
}

记得之前有个面试题就是类成员函数void  f() const是什么意思

就是保证这个函数不会修改类的数据成员

这篇文章写得比较好http://www.cnblogs.com/Fancyboy2004/archive/2008/12/23/1360810.html

关于Const函数的几点规则：
a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的

这个例子你可以看到，我们的对象b是const的，本来就是不希望被改变，虽然它声明为const，只是通过它没法改变，但是通过外部的因素还是会变。

怎么防止呢？

修改函数为

声明为

operator const char *() const;

定义为：

inline string::operator const char*() const 

{ return data; }

第二种情况，我测试了一下，无论是g++ 还是vs编译出来的结果都和书上不一样，是正确的。

它的意思是临时变量需要注意例如：

mystring testfunction()
{
    return "test";
}

这个时候，这个时候如果mystring a = testfunction();

a里面应该不是test,

但是我测试结果都是test,不知道是不是我理解的不对。

条款30: 避免这样的成员函数：其返回值是指向成员的非const指针或引用，但成员的访问级比这个函数要低

这个条款，我看的不太明白，以后再补充。