剑指Offer读书笔记(1)

2章

2.2编程语言

1.C++中定义一个空类型，对该类型求sizeof()为1，声明该类型时它必须在内存中占有一定的空间，即使加入构造函数和析构函数结果还是1。编译器如果发现一个类型中包含虚拟函数，就为该类型生成虚拟函数表，并在该类型的每一个实例中加入一个指向指针，此时求sizeof()时，在32位下为4,64位下为8。

2.C++中，struct定义的类型中默认是public,class中默认为private。

3.赋值运算符函数

在定义运算符函数时应考虑到：

A.是否把返回值的类型声明为引用，并在结束前返回实例自身的引用（即*this）,以解决连续赋值的问题。

B.是否把传入参数的类型声明为常引用，避免传入参数被修改和递归构造函数减少开销。

C.是否释放实例自身的内存，防止内存泄漏。

D.是否判断插入的参数和当前的实例是不是同一个实例。

CMySring& CMyString::operator=(const CMySrting &str)
{
	if (this == &str)
	{
		return *this;
	}							

	delete[] m_pData;
	m_pData = NULL;

	m_pData = new char(sizeof(str.m_pData) + 1);
	strcpy(m_pData, str.m_pData);
	return *this;
}

存在的问题在于当内存不足导致new char抛异常，m_pData将是一个空指针，这样非常容易导致程序崩溃。也就是说一旦在赋值运算符函数内部抛出一个异常，CMyString的实例不再保持有效的状态，这就违背了异常安全性的原则。

解决在赋值运算符函数中实现异常安全性：

（1）先用new分配新内存，再用delete释放已有的内容

（2） 先创建一个临时实例，在交换临时实例和原来的实例

//解决方案
CMyString& CMyString::operator=(const CMyString &str)
{
	if (this != str)
	{
		CMyString strTemp(str);
		char* pTemp = strTemp.m_pData;
		strTemp.m_pData = m_pData;	
		m_pData = pTemp;			
	}
	return *this;
}

#pragma once
#include <string>

class MyString
{
public:
	MyString(char* pdata = NULL)
	{
		if (pdata == NULL)
		{
			_data = new char[1];
			*_data = '\0';
		}
		else
		{
			int length = strlen(pdata);
			_data = new char[length + 1];
			strcpy(_data, pdata);
		}
	}
	MyString (const MyString& str)
	{
		int length = strlen(str._data);
		_data = new char[length + 1];
		strcpy(_data, str._data);
	}
	MyString& operator=(const MyString& str)
	{
		if (this == &str)
			return *this;

		delete[] _data;
		_data = NULL;

		_data = new char[strlen(str._data) + 1];
		strcpy(_data, str._data);

		return *this;
	}

	void PrintMyString()
	{
		printf("%s", _data);
	}
protected:
	char* _data;
};

void TestMyString()
{
	char* str = "hello world.";
	MyString str1;
	str1 = str;
	str1.PrintMyString();
	MyString str2(str1);
	str2.PrintMyString();
}