【剑指offer 001】C++编程基础

1 编程语言

问题1：在C++中，有哪4个与类型转换相关的关键字？

解答：首先，C++与类型转换相关的四个关键字有：const_cast, static_cast, dynamic_cast, reinterpret_cast.

什么是类型转换？
表达式是否合法取决于操作数的类型，而且合法的表达式其含义也由操作数类型决定。但是在C++中，某些类型之间存在相关的依赖关系。若两种类型相关，则可在需要某种类型的操作数位置上，使用该类型的相关类型对象或值。如果两个类型之间可以相互转换，则称这两个类型相关。

那么，第一个关键字登场了，static_cast关键字就是提供这种场合下的类型转换。C++默认的整数类型之间的转换就属于这种。

与之相反，如果被转换的两种类型之间不相关，比如int指针转换为char指针，就要使用reinterpret_cast这个关键字。

接下来登场的是const_cast。 使用const_cast会消除被转换类型的const特性，而且只有const类型的变量才能使用。那么，什么情况下需要消除一个const变量的const特性呢？比如，有时候有的函数的形参类型为非const类型，那么如果你要将一个const类型的参数传入就会报错。所以在这种情况下需要先使用const_cast转化一下。

 补充：
在上面四个类型转化关键字中，除了static_cast，其他的三个都有可能涉及到指针的类型转换。从本质上来说，指针的类型不同，并没有产生很大的差异，他们都是需要足够的内存来存放一个机器地址。“指向不同类型之各指针”间的差异，既不在其指针表示法不同，也不在其内容（代表一个地址）不同，而是在其所寻址出来的object不同。也就是说，“指针类型”会教导编译器如何解释某个特定地址中的内存内容及其大小。
所以，转换（cast）其实是一种编译器指令。大部分情况下它并不改变一个指针所含的真正地址，它只影响“被指出之内存大小和其内容”的解释方式。

问题2：定义一个空的类型，里面没有任何成员变量和成员函数。对该类型求sizeof,得到的结果是多少？

解答：答案是1

空类型的实例中不包含任何信息，本来求sizeof应该是0，但是当我们声明该类型的实例的时候，它必须在内存中占有一定的空间，否则无法使用这些实例。至于占用多少内存，有编译器决定。visual studio中每个空类型的实例占用1字节的空间。如果在该类型中添加一个构造函数和析构函数还是1.因为调用构造函数和析构函数只需要知道函数的地址即可，而这些函数的地址只与类型有关，而与类型的实例无关。如果把析构函数标记为虚函数呢？C++编译器一旦发现一个类型中有虚函数，就会为该类型生成虚函数表，并在该类型的每一个实例中添加一个指向虚函数表的指针。在32bit的机器上，一个指针占4字节。64bit的机器上一个指针占8字节。

问题3：如下代码，分析编译运行的结果  A编译出错 B编译成功，运行时程序奔溃 C编译运行正常 D输出 10

#include <iostream>
using namespace std;

class A{
private:
	int value;
public:
	A(int n){ value = n; }
	A(A other){ value = other.value;}
	void Print(){ std:cout << value << std::endl; }
};

int main(){

	A a = 10;
	A b = a;
	b.Print;
	return 0;
}

在上诉代码中，复制构造函数A（A other）传入的参数是A的一个实例。由于是传值参数，我们把形参复制到实参会调用复制构造函数。因此如果允许复制构造函数传值，就会在复制的构造函数内调用复制构造函数，就会形成永无休止的递归调用从而导致栈溢出。因此C++标准不允许复制构造函数，传值参数在VS和GCC中，都将编译出错。要解决这个问题，我们可以把构造函数修改为A（const A&other）也就是把传值参数改为常量引用。

问题4：如下为类型CMyString的声明，请为该类型添加赋值运算符函数

class CMyString{
public:
	CMyString(char* pData = NULL);
	CMyString(const CMyString& str);
	~CMyString(void);
private:
	char* m_pData;
};

在写代码时我们应该注意以下几点：
（1）是否把返回值的类型声明为该类型的引用，并在函数结束前返回实例自身的引用（即*this）。只有返回一个引用，才可以允许连续赋值。
否则如果函数的返回值是void,应用该赋值运算符将不能做连续赋值。
（2）是否把传入的参数的类型声明为常量引用。如果传入的参数不是引用而是实例，那么从形参到实参会调用一次复制构造函数。把参数声明为
引用可以避免这样的无谓消耗，能提高代码的效率。同时，我们在赋值运算符函数内不会改变传入的实例的状态，因此应该为传入的引用参数
加上const关键字
（3）是否释放实例自己已有的内存。如果我们忘记在分配内存之前释放自身已有的空间，程序将出现内存泄露。
（4）是否判断传入的参数和当前实例（*this）是不是同一个实例。如果是同一个则不进行赋值操作，直接返回。如果事先不判断就进行赋值，
那么在释放实例自身的内存的时候就会导致严重的问题：当*this和传入的参数是同一个实例时，那么一旦释放了自身的内存，传入的参数的
内存也同时被释放了，因此再也找不到需要赋值的内容了。

经典解法：

CMyString& CMyString::operator=(const CMyString&str){

	if (this == &str)
		return *this;
	delete[]m_pData;
	m_pData = NULL;
	m_pData = new char[strlen(str.m_pData) + 1];
	strcpy(m_pData, str.m_pData);

	return *this;
}

2 数据结构

2.1 数组

数组占据了一块连续的内存并按照顺序存储数据。由于数组中的内存是连续的，因此它的时间效率很高。但即使我们只在数组中存储一个数字，也需要为所有的数据先分配内存，因此数组的空间效率不是很好，为解决该问题，人们又实现了多种动态数组，比如C++的STL中的vector,使用vector时要尽量减少改变数组容量大小的次数。
题目五：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个二维数组和一个整数，判断数组中是否含有该整数。如在下面的数组中查找数字7
1  2  8   9
2  4  9   12
4  7  10  13
6  8  11  15
解决复杂问题一个简单的办法就是从具体的问题入手。总结查找过程发现如下规律：首先选取数组中右上角的数字，如果等于查找的数字查找过程结束，如果该数字大于查找的数字，剔除这个数字所在的列；如果该数字小于要查找的数字，剔除这个数字所在的行。

编码：

#include<iostream>
using namespace std;

bool Find(int* matrix, int rows, int columns, int number){

	bool found = false;
	if (matrix != NULL&&rows > 0 && columns > 0)
	{
		int row = 0;
		int column = columns - 1;
		while (row < rows&&column >= 0)
		{
			if (matrix[row*columns + column] == number)
			{
				found = true;
				break;
			}
			else if (matrix[row*columns + column]>number)
				--column;
			else ++row;
		}
	}
	return found;
}
int main(){

	int myArray[16] = {1, 2, 8, 9, 2, 4, 9, 12, 4, 7, 10, 13, 6, 8, 11, 15 };

	if (Find(myArray, 4, 4, 7)){
		printf("找到数字\n");
	}
	else
		printf("没有找到数字\n");

	std::system("pause");
	return 0;
}

2.2 字符串

字符串是由若干字符组成的序列，C/C++中每个字符串都以字符‘\0’作为结尾。

题目六：请实现一个函数，把字符窜中的每个空格替换成“%20”。例如输入“we are happy”,则输出“we%20are%20happy.”

在网络编程中，如果url参数中含有特殊字符，如空格、‘#’等，可能导致服务器端无法获得正确的参数值，我们需要将这些字符转换为服务器可以识别的字符。遇到该问题我们可以有两种方案，方案一：在原来的字符串上做替换，有可能覆盖修改在该字符串后面的内存。方案二：创建新的字符串在新的字符串上做替换。我们使用方案一，如果考虑从头到尾扫描字符串，每一次碰到空格字符的时候做替换，假设字符串的长度是n，对每个空格字符，需要移动后面O(n)个字符，因此对含有O(n)个空格字符串而言总的时间效率是O(n²)。但是如果我们换一种思路，把从前到后替换改成从后到前替换。我们可以先遍历一次字符串，这样就能统计出字符串中空格的总数，并可以由此计算出替换之后的字符串对的总长度，这样分析所有的字符都只复制（移动）一次，因此这个算法的时间效率是O(n),比第一个思路要快。参考代码如下

#include <iostream>
using namespace std;

//length为字符数组string的总容量
void ReplaceBlank(char string[], int length){

	if (string == NULL || length <= 0)return;

	//originalLength为字符串string的实际长度
	int originalLength = 0;
	int numberOfBlank = 0;
	int i = 0;

	while (string[i] != '\0')
	{
		++originalLength;
		if (string[i] == ' ')
			++numberOfBlank;
		++i;
	}

	int newLength = originalLength + numberOfBlank * 2;
	if (newLength > length) return;

	int indexOfOriginal = originalLength;
	int indexOfNew = newLength;
	while (indexOfOriginal >= 0 && indexOfNew > indexOfOriginal)
	{
		if (string[indexOfOriginal]==' ')
		{
			string[indexOfNew--] = '0';
			string[indexOfNew--] = '2';
			string[indexOfNew--] = '%';
		}
		else
		{
			string[indexOfNew--] = string[indexOfOriginal];
		}
		--indexOfOriginal;
	}
}

int main(){

	char myStr[256] = "we are happy";
	ReplaceBlank(myStr, 256);
	printf("%s", myStr);
	system("pause");
	return 0;
}

2.3 链表

链表是由指针把若干个结点连接成链状结构，它是一种动态的数据结构，需要使用指针对其进行操作。链表是一种动态的数据结构是因为在创建链表
时，无需知道链表的长度，当插入一个结点时，我们只需要为新结点分配内存，然后调整指针的指向来确保新结点别链接到链表当中。由于没有闲置
的内存，链表的空间效率比数组高。
环形链表：把链表的末尾结点的指针指向头结点，从而形成一个环形链表。
双向链表：链表中的结点中除了有指向下一个结点的指针，还有指向前一个结点的指针。
复杂链表：链表中的结点中除了有指向下一个结点的指针还有指向任意结点的指针。
题目七：输入一个链表的头结点，从尾到头反过来打印出每个结点的值。
思路一：这是一种典型的“后进先出”，我们可以用栈实现这种顺序。每经过一个结点的时候，把该结点放到一个栈中。当遍历
完整个链表后，再从栈顶开始逐个输出结点的值，此时输出的结点的顺序已经反转过来了。
思路二：既然想到了用栈实现这个函数，而递归的本质就是一个栈结构。我们每访问到一个结点的时候，先递归输出它后面的结点，再输出该结点
自身，这样链表就反过来了。
主要考察对单链表的理解和编程能力以及对循环、递归和栈3个相互关联的概念的理解。

#include <iostream>
#include <stack>
using namespace std;

struct ListNode{
	int m_nValue;
	ListNode *m_pNext;
};

void AddToTail(ListNode* pHead, int value){

	ListNode* pNew = new ListNode();
	pNew->m_nValue = value;
	pNew->m_pNext = NULL;

	if (pHead == NULL)
	{
		pHead = pNew;
	}
	else
	{
		ListNode *pNode = pHead;
		while (pNode->m_pNext != NULL)
			pNode = pNode->m_pNext;
		pNode->m_pNext = pNew;
	}

}

//栈实现
void PrintListReversingly_Iteratively(ListNode *pHead){

	std::stack<ListNode*>nodes;
	ListNode* pNode = pHead;
	while (pNode!=NULL)
	{
		nodes.push(pNode);
		pNode = pNode->m_pNext;
	}

	while (!nodes.empty())
	{
		pNode = nodes.top();
		printf("%d\t", pNode->m_nValue);
		nodes.pop();
	}
}

//递归实现
/*
递归代码看起来简洁，但有个问题：当链表非常长的时候就会导致函数调用的层级很深，从而可能导致函数调用栈溢出，
显示用栈基于循环实现的代码的鲁棒性要好一些。
*/
void PrintListReversingly_Recursively(ListNode* pHead){

	if (pHead != NULL)
	{
		if (pHead->m_pNext != NULL)
		{
			PrintListReversingly_Recursively(pHead->m_pNext);
		}
		printf("%d\t", pHead->m_nValue);
	}
}

int main(){

	ListNode *myListNode;
	myListNode = new ListNode;
	myListNode->m_nValue = 1;
	myListNode->m_pNext = NULL;
	AddToTail(myListNode, 2);
	AddToTail(myListNode, 3);
	PrintListReversingly_Iteratively(myListNode);
	printf("\n");
	PrintListReversingly_Recursively(myListNode);
	system("pause");
	return 0;
}

2.4 树

2.5 栈和队列

3 算法和数据操作