C++编程调试秘笈----读书笔记(6)

六、一些杂项

1、避免编写拷贝构造函数和赋值操作符，如果默认版本并不适用，可以考虑把拷贝构造函数和赋值操作符声明为私有，禁止类实例的复制

2、避免在析构函数中编写代码

需要析构函数的原因可能有好几个：

a、在基类中，可能需要声明虚拟析构函数，这样就可以使用一个指向基类的指针指向一个派生类的实例

b、在派生类中，并不需要把析构函数声明为虚拟函数，但是为了增加可读性，也可以这样做

c、可能需要声明析构函数并不抛出任何异常

下来讨论一下为什么析构函数应该是空的：

class Student
{
public:
	Student
	{
		if (!number_)
		{
			number_ = new int(age);
		}
	}

	~Student()
	{
		if (number_)
		{
			delete number_;
		}
	}

private:
	int* number_;
};

看看这个Student类，因为他在构造函数中获取了一些资源，所以需要在析构函数中释放掉。

但是现在问题来了，这个类的设计----每次添加一个表示个人描述的新元素(例如number_)时，都需要在析构函数中添加对应的清理代码，这就违背了“不要迫使程序员记住某些事情”的原则；另一个问题是，缺少安全检查，首先你的number_可能是要必须大于0的，这样还得在new的前面进行if判断，另外一个极端的情况：

#include "stdafx.h"
#include "iostream"
#include "string"

class A
{
public:
	A() { std::cout << "Creating A" << std::endl; }
	~A(){ std::cout << "Destroying A" << std::endl; }
};

class B
{
public:
	B() { std::cout << "Creating B" << std::endl; }
	~B(){ std::cout << "Destroying B" << std::endl; }
};

class C : public A
{
public:
	C() 
	{ 
		std::cout << "Creating C" << std::endl; 
		throw "Don't like C";
	}
	~C(){ std::cout << "Destroying C" << std::endl; }
private:
	B b_;
};

int _tmain(int argc, _TCHAR* argv[])
{
	try
	{
		C c;
	}
	catch (...)
	{
		std::cout << "Caught an exception" << std::endl;
	}

	return 0;
}

因为在C中throw了一个异常，所以导致class C的析构函数没有被执行，这就导致了一些问题的产生

改成下面的形式设计就要好得多：

class Student
{
public:
	Student(const int number, const char* name)
	{
		SCPP_ASSERT(number > 0, "number must be large 0");
		number_ = new int(number);
		SCPP_ASSERT(name != NULL, "name must be not null");
		name_ = new std::string(name);
	}

	~Student()
	{
	}
private:
	Student(const Student& student);
	Student& operator = (const Student&);

	scpp::ScopedPtr<int> number_;
	scpp::ScopedPtr<std::string> name_;
};

即使第二个安全检查抛出异常，执行name_的智能指针的析构函数仍然会被调用，并执行他的清理工作。另一个附带的好处是，我们并不需要操心把这些智能指针初始化为NULL，这是自动完成的。因此，可以看到构造函数抛出异常是一种潜在的危险行为；对应的析构函数将不会被调用，因此可能会存在问题，除非析构函数是空函数。

3、编写一致的比较操作符

常用的操作符有< > <= >= == !=，站在C++的角度，这些操作可以写成6个相互完全独立的函数，但是他们相互之间又有联系，比如x1>x2成立，x2<x1和x1>=x2也是成立的。所以，我们需要一些步骤来帮我实现这个目标(往之前的scpp_types.h上面添加)：

#ifndef __SCCP_TYPES_H__
#define __SCCP_TYPES_H__

#include <ostream>
#include "scpp_assert.h"

template <typename T>
class TNumber
{
public:
	TNumber(const T& x =0 )
		:data_(x)
	{

	}
	operator T() const 
	{
		return data_;
	}

	TNumber &operator = (const T& x)
	{
		data_ = x;
		return *this;
	}

	TNumber operator ++(int)
	{
		TNumber<T> copy(*this);
		++data_;
		return copy;
	}

	TNumber operator ++()
	{
		++data_;
		return *this;
	}

	TNumber& operator += (T x)
	{
		data_ += x;
		return *this;
	}

	TNumber& operator -= (T x)
	{
		data_ -= x;
		return *this;
	}

	TNumber& operator *= (T x)
	{
		data_ *= x;
		return *this;
	}

	TNumber& operator /= (T x)
	{
		SCPP_ASSERT(x != 0, "Attempt to divide by 0");
		data_ /= x;
		return *this;
	}

	T operator / (T x)
	{
		SCPP_ASSERT(x != 0, "Attempt to divide by 0");
		return data_ / x;
	}

private:
	T data_;
};

typedef long long int64;
typedef unsigned long long unsigned64;

typedef TNumber<int>		Int;
typedef TNumber<unsigned>	Unsigned;
typedef TNumber<int64>		Int64;
typedef TNumber<unsigned64> Unsigned64;
typedef TNumber<float>		Float;
typedef TNumber<double>		Double;
typedef TNumber<char>		Char;

class Bool
{
public:
	Bool(bool x = false)
		:data_(x)
	{
	}

	operator bool () const
	{
		return data_;
	}

	Bool& operator = (bool x)
	{
		data_ = x;
		return *this;
	}

	Bool& operator &= (bool x)
	{
		data_ &= x;
		return *this;
	}

	Bool& operator |= (bool x)
	{
		data_ |= x;
		return *this;
	}

private:
	bool data_;
};

inline std::ostream& operator << (std::ostream& os, Bool b)
{
	if (b)
	{
		os << "True";
	}
	else
	{
		os << "False";
	}
	return os;
}

#define SCPP_DEFINE_COMPARISON_OPERATORS(Class) \
	bool operator < (const Class& that) const { return CompareTo(that) < 0; } \
	bool operator > (const Class& that) const { return CompareTo(that) > 0; } \
	bool operator ==(const Class& that) const { return CompareTo(that) ==0; } \
	bool operator <=(const Class& that) const { return CompareTo(that) <=0; } \
	bool operator >=(const Class& that) const { return CompareTo(that) >=0; } \
	bool operator !=(const Class& that) const { return CompareTo(that) !=0; } 

#endif

 

测试代码(vs2012+win7环境)：

#include "stdafx.h"
#include "scpp_assert.h"
#include "iostream"
#include "scpp_vector.h"
#include "scpp_array.h"
#include "scpp_matrix.h"
#include "algorithm"
#include "scpp_types.h"
#include "scpp_refcountptr.h"
#include "scpp_scopedptr.h"
#include "scpp_ptr.h"
#include "string"

#define STUDENTAGE 10

class Student
{
public:
	Student(int age)
	{
		SCPP_ASSERT(age > 0, "number must be large 0");
		age_ = age;
	}

	int CompareTo(const Student& that) const
	{
		if (this->age_ > that.age_)
		{
			return 1;
		}
		else if(this->age_ == that.age_)
		{
			return 0;
		}
		else
		{
			return -1;
		}
	}
	SCPP_DEFINE_COMPARISON_OPERATORS(Student);
private:
	int age_;
};

int _tmain(int argc, _TCHAR* argv[])
{
	Student studentFirst(STUDENTAGE);
	Student studentSecond(STUDENTAGE);

	if (studentFirst >= studentSecond)
	{
		std::cout << "(studentFirst > studentSecond) && (studentFirst == studentSecond)" << std::endl;
	}

	return 0;
}

 

4、使用标准C函数库的错误

C函数库中，在好几个方面都是不安全的，还可能导致程序崩溃

比如使用stdio.h中想sprintf()这样的函数可能会有下面的问题：

a、有些函数接受字符数组的指针(char *)，如果向他们传递一个NULL而不是指向合法的C字符串的指针，将会崩溃(比如strlen(NULL);就可以秒掉程序)

b、有些函数将写入一个缓冲区，他们可能会改写越过缓冲区尾部的内存，从而导致不可预料的程序行为

.....

上面的问题，可以这样处理：

a、提供执行所有必要安全检查的版本，并按照与处理空字符串的相同方式处理NULL指针

b、对于不能牺牲字符串操作速度的应用程序，提供只在测试时才激活的临时安全检查的函数版本

......

但是，这些问题最好的解决方案是不用C字符串函数库，而是改用C++所提供的类，比如：

strlen(name)可以改用name.size()，对于strcpy()可以仅仅 使用字符串赋值操作符；strcat()或strncat()可以改用：

int _tmain(int argc, _TCHAR* argv[])
{

	std::ostringstream buffer;
	buffer << "zeng";
	buffer << "raoli";
	std::string result = buffer.str();

	std::cout << "this result string is : " << result << std::endl;

	return 0;
}

或者采用更简短的形式：

int _tmain(int argc, _TCHAR* argv[])
{
	std::string result = "zeng";
	result += "raoli";

	std::cout << "this result string is : " << result << std::endl;

	return 0;
}

这些代码不仅更容易阅读，并且更安全，而且对于较长的字符串，他们的速度也快于strcat()！因为不存在需要分配和改写缓冲区