第八章编程练习

1.编写一个通常接受一个参数（字符串的地址），并打印该字符串的函数。然而，如果提供了第二个参数（int类型），且该参数不为0，则该函数打印字符串的次数将为该函数被调用的次数（注意，字符串的打印次数不等于第二个参数的值，而等于函数被调用的次数）。是的，这是一个非常可笑的函数，但它让您能够使用本章介绍的一些技术。在一个简单的程序中使用该函数，以演示该函数时如何工作的。

void PrintString(const char* str, int n = 0);

int main(void)
{
	PrintString("hello world");
	PrintString("Good moring");
	PrintString("I love you", 8);

	return 0;
}

void PrintString(const char* str, int n)
{
	static int count = 0;
	count++;

	if (n == 0)
	{
		cout << str << endl;
	}
	else
	{
		for (int i = 0; i < count; i++)
		{
			cout << str << endl;
		}
	}
}

2.CandyBar结构包含3个成员。第一个成员存储candy bar的品牌名称；第二个成员存储candy bar的重量（可能有小数）；第三个成员存储candy bar的热量（整数）。请编写一个程序，它使用一个这样的函数，即将CandyBar的引用、char数组、double和int作为参数，并用最后3个值设置相应的结构成员。最后3个参数的默认值分别为"Millennium Munch"、2.85和350。另外，该程序还包含一个以CandyBar的引用为参数，并显示结构内容的函数。请尽可能使用const。

const int SIZE = 20;

struct CandyBar
{
	char brand[SIZE];//品牌名称
	double weight;	 //重量
	int heat;		 //热量
};

void SetValue(CandyBar &candybar, const char* str = "Millennium Munch", const double weight = 2.85, const int heat = 350);
void Show(const CandyBar &candybar);

int main(void)
{
	CandyBar candy_bar;

	SetValue(candy_bar);
	Show(candy_bar);

	return 0;
}

void SetValue(CandyBar& candybar, const char* str, const double weight, const  int heat)
{
	strcpy(candybar.brand, str);
	candybar.weight = weight;
	candybar.heat = heat;
}
void Show(const CandyBar &candybar)
{
	cout << "Brand: " << candybar.brand << endl;
	cout << "Weight: " << candybar.weight << endl;
	cout << "Heat: " << candybar.heat << endl;
}

3.编写一个函数，它接受一个指向string对象的引用作为参数，并将该string对象的内容转换为大写，为此可使用表6.4描述的函数toupper()。然后编写一个程序，它通过使用一个循环让您能够用不同的输入来测试这个函数，该程序的运行情况如下：
Enter a string(q to quit): go away
GO AWAY
Next string(q to quit): good grief!
GOOD GRIEF!
Next string(q to quit) :q
Bye

void ToUpper(string &str);

int main(void)
{
	string str;
	cout << "Please enter a string(q to quit):";
	getline(cin, str);

	while (str != "q")
	{
		ToUpper(str);
		cout << str << endl;
		cout << "Enter a string(q to quit):";
		getline(cin, str);
	}

	cout << "Bye" << endl;

	return 0;
}

void ToUpper(string &str)
{
	for (int i = 0; i < str.size(); i++)
	{
		str[i] = toupper(str[i]);
	}
}

4.请根据其中描述的函数和原型，从而完成该程序。注意，应有两个Show()函数，每个都使用默认参数。请尽可能使用const参数。Set()使用new分配足够的空间来存储指定的字符串。这里使用的技术与设计和实现时使用的相似。（可能还必须修改头文件的名称，删除using编译指令，这取决于所用的编译器。）

Stringy beany;
	char testing[] = "Reality isn't what is used to be.";

	Set(beany, testing);//first argument is a reference, allocates space to hold copy of testing
						//sets str member of beany to point to the new block, copies testing to new block
						//and sets ct member of beany
	Show(beany);//prints member string once
	Show(beany, 2);//prints member string twice
	testing[0] = 'D';
	testing[1] = 'u';
	Show(testing);//prints testing string once
	Show(testing, 3);//prints testing string thrice
	Show("Done!");

实现：

struct Stringy
{
	char* str;
	int ct;
};

void Set(Stringy& stringy, const char* str);
void Show(const Stringy& stringy, int num = 1);
void Show(const char* str, int num = 1);

int main(void)
{
	Stringy beany;
	char testing[] = "Reality isn't what is used to be.";

	Set(beany, testing);//first argument is a reference, allocates space to hold copy of testing
						//sets str member of beany to point to the new block, copies testing to new block
						//and sets ct member of beany
	Show(beany);//prints member string once
	Show(beany, 2);//prints member string twice
	testing[0] = 'D';
	testing[1] = 'u';
	Show(testing);//prints testing string once
	Show(testing, 3);//prints testing string thrice
	Show("Done!");


	return 0;
}

void Set(Stringy& stringy, const char* str)
{
	stringy.ct = strlen(str) + 1;
	stringy.str = new char[stringy.ct];
	strcpy(stringy.str, str);
}

void Show(const Stringy& stringy, int num)
{
	for (int i = 0; i < num; i++)
	{
		cout << stringy.str << endl;
	}
}

void Show(const char* str, int num)
{
	for (int i = 0; i < num; i++)
	{
		cout << str << endl;
	}
}

5.编写模板函数max5()，它将一个包含5个T类型元素的数组作为参数，并返回数组中最大的元素（由于长度固定，因此可以在循环中使用硬编码，而不必通过参数来传递）。在一个程序中使用该函数，将T替换为一个包含5个int值的数组和一个5个包含double值的数组，测试该函数。

template <typename T>
T max5(T t[]);


int main(void)
{
	int arr1[5] = { 1,3,5,7,9 };
	double arr2[5] = { 22.2, 13.8, 17.9, 54.2, 38.4 };
	
	cout << "The max value of int arr1 is " << max5(arr1) << endl;
	cout << "The max value of double arr2 is " << max5(arr2) << endl;
	return 0;
}


template <typename T>
T max5(T t[])
{
	T max = t[0];
	for (int i = 1; i < 5; i++)
	{
		if (max < t[i])
		{
			max = t[i];
		}
	}

	return max;
}

6.编写模板函数maxn()，它将由一个T类型元素组成的数组和一个表示数组元素数目的整数作为参数，并返回数组中最大的元素。在程序中对它进行测试，该程序使用一个包含6个int元素的数组和一个包含4个double元素的数组来调用该函数。程序还包含一个具体化，它将char指针数组和数组中的指针数量作为参数，并返回最长的字符串的地址。如果有多个这样的字符串，则返回其中第一个字符串的地址。使用由5个字符串指针组成的数组来测试该具体化。

template <typename T>
T maxn(T t[], int n);

template <>
string maxn(string str[], int n);

int main(void)
{
	int arr1[6] = { 1,3,5,7,9,11 };
	double arr2[5] = { 22.2, 13.8, 17.9, 38.4 };
	string arr3[5] = {"hello world", "good moring", "I love you", "how are you", "Byebye"};

	cout << "The max value of int arr1 is " << maxn(arr1, 6) << endl;
	cout << "The max value of double arr2 is " << maxn(arr2, 4) << endl;
	cout << "The max value of string arr3 is " << maxn(arr3, 5) << endl;

	return 0;
}

template <typename T>
T maxn(T t[], int n)
{
	T max = t[0];
	for (int i = 1; i < n; i++)
	{
		if (max < t[i])
		{
			max = t[i];
		}
	}

	return max;
}

template <> //具体化
string maxn(string str[], int n)
{
	int pos = 0;
	for (int i = 1; i < n; i++)
	{
		if ( str[pos].size() < str[i].size() )
		{
			pos = i;
		}
	}
	return str[pos];
}

7.修改程序清单8.14，使其使用两个名为SumArray()的模板函数来返回数组元素的综合，而不是显示数组的内容。程序应显示thing的综合以及所有debt的总和。

template <typename T>
void ShowArray(T arr[], int n);

template <typename T>
void ShowArray(T* arr[], int n);

template <typename T>
T SumArray(T arr[], int n);

template <typename T>
T SumArray(T* arr[], int n);

struct Debts
{
	char name[50];
	double amount;
};

int main(void)
{
	int things[6] = {13, 31, 103, 301, 310, 130};
	struct Debts mr_E[3] =
	{
		{"Ima Wolfe", 2400.0},
		{"Ura Foxe", 1300.0},
		{"Iby Stout", 1800.0}
	};
	double* pd[3];

	for (int i = 0; i < 3; i++)
	{
		pd[i] = &mr_E[i].amount;
	}

	cout << "Listing Mr.E's counts of things:\n";
	ShowArray(things, 6);
	cout << "Listing Mr.E's debts:\n";
	ShowArray(pd, 3);

	cout << "The sum of things: " << SumArray(things, 6) << endl;
	cout << "The sum of pd: " << SumArray(pd, 3) << endl;

	return 0;
}

template <typename T>
void ShowArray(T arr[], int n)
{
	cout << "====template A====\n";
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}


template <typename T>
void ShowArray(T* arr[], int n)
{
	cout << "====template B====\n";
	for (int i = 0; i < n; i++)
	{
		cout << *arr[i] << " ";
	}
	cout << endl;
}

template <typename T>
T SumArray(T arr[], int n)
{
	T sum = 0;
	cout << "====template C====\n";
	for (int i = 0; i < n; i++)
	{
		sum += arr[i];
	}
	return sum;
}

template <typename T>
T SumArray(T* arr[], int n)
{
	T sum = 0;
	cout << "====template D====\n";
	for (int i = 0; i < n; i++)
	{
		sum += *arr[i];
	}
	return sum;
}