C++ primer plus(第六版)编程练习答案第8章函数探幽

左手的ㄟ右手 2024-03-24 08:34 88阅读 0赞

## 一、程序清单 ##

## inline.cpp ##

// inline.cpp -- using an inline function
    #include <iostream>
    
    // an inline function definition
    inline double square(double x) { return x * x; }
    int main()
    {
    	using namespace std;
    	double a, b;
    	double c = 13.0;
    
    	a = square(5.0);
    	b = square(4.5 + 7.5);   // can pass expressions
    	cout << "a = " << a << ", b = " << b << "\n";
    	cout << "c = " << c;
    	cout << ", c squared = " << square(c++) << "\n";
    	cout << "Now c = " << c << "\n";
    	// cin.get();
    	return 0;
    }

执行结果：

a = 25, b = 144
    c = 13, c squared = 169
    Now c = 14

## firstref.cpp ##

// firstref.cpp -- defining and using a reference
    #include <iostream>
    int main()
    {
        using namespace std;
        int rats = 101;
        int & rodents = rats;   // rodents is a reference
    
        cout << "rats = " << rats;
        cout << ", rodents = " << rodents << endl;
        rodents++;
        cout << "rats = " << rats;
        cout << ", rodents = " << rodents << endl;
    
    // some implementations require type casting the following
    // addresses to type unsigned
        cout << "rats address = " << &rats;
        cout << ", rodents address = " << &rodents << endl;
        // cin.get();
        return 0; 
    }

执行结果：

rats = 101, rodents = 101
    rats = 102, rodents = 102
    rats address = 00CFF9C4, rodents address = 00CFF9C4

## secref.cpp ##

// secref.cpp -- defining and using a reference
    #include <iostream>
    int main()
    {
    	using namespace std;
    	int rats = 101;
    	int & rodents = rats;   // rodents is a reference
    
    	cout << "rats = " << rats;
    	cout << ", rodents = " << rodents << endl;
    
    	cout << "rats address = " << &rats;
    	cout << ", rodents address = " << &rodents << endl;
    
    	int bunnies = 50;
    	rodents = bunnies;       // can we change the reference?
    	cout << "bunnies = " << bunnies;
    	cout << ", rats = " << rats;
    	cout << ", rodents = " << rodents << endl;
    
    	cout << "bunnies address = " << &bunnies;
    	cout << ", rodents address = " << &rodents << endl;
    	// cin.get();
    	return 0;
    }

执行结果：

rats = 101, rodents = 101
    rats address = 00CFFDB4, rodents address = 00CFFDB4
    bunnies = 50, rats = 50, rodents = 50
    bunnies address = 00CFFD9C, rodents address = 00CFFDB4

## swaps.cpp ##

// swaps.cpp -- swapping with references and with pointers
    #include <iostream>
    void swapr(int & a, int & b);   // a, b are aliases for ints
    void swapp(int * p, int * q);   // p, q are addresses of ints
    void swapv(int a, int b);       // a, b are new variables
    int main()
    {
    	using namespace std;
    	int wallet1 = 300;
    	int wallet2 = 350;
    
    	cout << "wallet1 = $" << wallet1;
    	cout << " wallet2 = $" << wallet2 << endl;
    
    	cout << "Using references to swap contents:\n";
    	swapr(wallet1, wallet2);   // pass variables
    	cout << "wallet1 = $" << wallet1;
    	cout << " wallet2 = $" << wallet2 << endl;
    
    	cout << "Using pointers to swap contents again:\n";
    	swapp(&wallet1, &wallet2); // pass addresses of variables
    	cout << "wallet1 = $" << wallet1;
    	cout << " wallet2 = $" << wallet2 << endl;
    
    	cout << "Trying to use passing by value:\n";
    	swapv(wallet1, wallet2);   // pass values of variables
    	cout << "wallet1 = $" << wallet1;
    	cout << " wallet2 = $" << wallet2 << endl;
    	// cin.get();
    	return 0;
    }
    
    void swapr(int & a, int & b)    // use references
    {
    	int temp;
    
    	temp = a;       // use a, b for values of variables
    	a = b;
    	b = temp;
    }
    
    void swapp(int * p, int * q)    // use pointers
    {
    	int temp;
    
    	temp = *p;      // use *p, *q for values of variables
    	*p = *q;
    	*q = temp;
    }
    
    void swapv(int a, int b)        // try using values
    {
    	int temp;
    
    	temp = a;      // use a, b for values of variables
    	a = b;
    	b = temp;
    }

执行效果：

wallet1 = $300 wallet2 = $350
    Using references to swap contents:
    wallet1 = $350 wallet2 = $300
    Using pointers to swap contents again:
    wallet1 = $300 wallet2 = $350
    Trying to use passing by value:
    wallet1 = $300 wallet2 = $350

## cubes.cpp ##

// cubes.cpp -- regular and reference arguments
    #include <iostream>
    double cube(double a);
    double refcube(double &ra);
    int main()
    {
    	using namespace std;
    	double x = 3.0;
    
    	cout << cube(x);
    	cout << " = cube of " << x << endl;
    	cout << refcube(x);
    	cout << " = cube of " << x << endl;
    	// cin.get();
    	return 0;
    }
    
    double cube(double a)
    {
    	a *= a * a;
    	return a;
    }
    
    double refcube(double &ra)
    {
    	ra *= ra * ra;
    	return ra;
    }

执行结果：

27 = cube of 3
    27 = cube of 27

## strc\_ref.cpp ##

//strc_ref.cpp -- using structure references
    #include <iostream>
    #include <string>
    struct free_throws
    {
    	std::string name;
    	int made;
    	int attempts;
    	float percent;
    };//free_throws结构
    
    void display(const free_throws & ft);
    void set_pc(free_throws & ft);
    free_throws & accumulate(free_throws &target, const free_throws &source);
    
    int main()
    {
    	free_throws one = { "Ifelsa Branch", 13, 14 };
    	free_throws two = { "Andor Knott", 10, 16 };
    	free_throws three = { "Minnie Max", 7, 9 };
    	free_throws four = { "Whily Looper", 5, 9 };
    	free_throws five = { "Long Long", 6, 14 };
    	free_throws team = { "Throwgoods", 0, 0 };
    	free_throws dup;
    	set_pc(one);
    	display(one);//调用display函数 
    	//Name: Ifelsa Branch    Made: 13      Attempts : 14    Percent : 92.8571
    	display(team);//Name: Throwgoods
        //Made: 0       Attempts : 0     Percent : 0
    	// use return value as argument
    	display(accumulate(team, two));//调用display函数 
        //Name: Throwgoods
    	//Made : 10      Attempts : 16    Percent : 62.5
    	accumulate(accumulate(team, three), four);//其中22=10+7+5 34=16+9+9 
    	//这里调用accumulate函数和前面的two累加到一起
    	display(team);//Name: Throwgoods
        //Made: 22      Attempts : 34    Percent : 64.7059 
    
    	// use return value in assignment
    	dup = accumulate(team, five);//22+6(five)=28 34+14(five)=48
    	std::cout << "Displaying team:\n";
    	display(team);//Name: Throwgoods
        //Made: 28      Attempts : 48    Percent : 58.3333
    	std::cout << "Displaying dup after assignment:\n";
    	display(dup);//Name: Throwgoods
        //Made: 28      Attempts : 48    Percent : 58.3333
    	set_pc(four);
    	// ill-advised assignment
    	accumulate(dup, five) = four;//首先将five的数据添加到dup中，再将four的内容覆盖dup的内容
    	std::cout << "Displaying dup after ill-advised assignment:\n";
    	display(dup);//Name: Whily Looper
        //Made: 5       Attempts : 9     Percent : 55.5556
    	// std::cin.get();
    	return 0;
    }
    
    void display(const free_throws & ft)
    {
    	using std::cout;
    	cout << "Name: " << ft.name << '\n';
    	cout << "  Made: " << ft.made << '\t';
    	cout << "Attempts: " << ft.attempts << '\t';
    	cout << "Percent: " << ft.percent << '\n';
    }
    void set_pc(free_throws & ft)
    {
    	if (ft.attempts != 0)
    		ft.percent = 100.0f *float(ft.made) / float(ft.attempts);//相当于100*13/14=92.85714285
    	else
    		ft.percent = 0;
    }
    
    free_throws & accumulate(free_throws & target, const free_throws & source)
    {
    	target.attempts += source.attempts;
    	target.made += source.made;
    	set_pc(target);
    	return target;
    }

执行结果：

Name: Ifelsa Branch
      Made: 13      Attempts: 14    Percent: 92.8571
    Name: Throwgoods
      Made: 0       Attempts: 0     Percent: 0
    Name: Throwgoods
      Made: 10      Attempts: 16    Percent: 62.5
    Name: Throwgoods
      Made: 22      Attempts: 34    Percent: 64.7059
    Displaying team:
    Name: Throwgoods
      Made: 28      Attempts: 48    Percent: 58.3333
    Displaying dup after assignment:
    Name: Throwgoods
      Made: 28      Attempts: 48    Percent: 58.3333
    Displaying dup after ill-advised assignment:
    Name: Whily Looper
      Made: 5       Attempts: 9     Percent: 55.5556

## strquote.cpp ##

// strquote.cpp  -- different designs
    #include <iostream>
    #include <string>
    using namespace std;
    string version1(const string & s1, const string & s2);
    const string & version2(string & s1, const string & s2);  // has side effect
    const string & version3(string & s1, const string & s2);  // bad design
    
    int main()
    {
    	string input;
    	string copy;
    	string result;
    
    	cout << "Enter a string: ";
    	getline(cin, input);
    	copy = input;
    	cout << "Your string as entered: " << input << endl;
    	result = version1(input, "***");
    	cout << "Your string enhanced: " << result << endl;
    	cout << "Your original string: " << input << endl;
    
    	result = version2(input, "###");
    	cout << "Your string enhanced: " << result << endl;
    	cout << "Your original string: " << input << endl;
    
    	cout << "Resetting original string.\n";
    	input = copy;
    	result = version3(input, "@@@");//执行错误，程序试图引用已经释放的内存
    	cout << "Your string enhanced: " << result << endl;
    	cout << "Your original string: " << input << endl;
    	// cin.get();
    	// cin.get();
    	return 0;
    }
    
    string version1(const string & s1, const string & s2)
    {
    	string temp;
    
    	temp = s2 + s1 + s2;
    	return temp;
    }
    
    const string & version2(string & s1, const string & s2)   // has side effect
    {
    	s1 = s2 + s1 + s2;
    	// safe to return reference passed to function
    	return s1;
    }
    
    const string & version3(string & s1, const string & s2)   // bad design
    {
    	string temp;
    
    	temp = s2 + s1 + s2;
    	// unsafe to return reference to local variable
    	return temp;
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16][]

执行结果：

Enter a string: It is my fault.
    Your string as entered: It is my fault.
    Your string enhanced: ***It is my fault.***
    Your original string: It is my fault.
    Your string enhanced: ###It is my fault.###
    Your original string: ###It is my fault.###
    Resetting original string.

## filefunc.cpp ##

//filefunc.cpp -- function with ostream & parameter
    #include <iostream>
    #include <fstream>
    #include <cstdlib>
    using namespace std;
    
    void file_it(ostream & os, double fo, const double fe[], int n);
    const int LIMIT = 5;
    int main()
    {
    	ofstream fout;
    	const char * fn = "ep-data.txt";
    	fout.open(fn);
    	if (!fout.is_open())
    	{
    		cout << "Can't open " << fn << ". Bye.\n";
    		exit(EXIT_FAILURE);
    	}
    	double objective;
    	cout << "Enter the focal length of your "
    		"telescope objective in mm: ";
    	cin >> objective;//输入1800
    	double eps[LIMIT];
    	cout << "Enter the focal lengths, in mm, of " << LIMIT
    		<< " eyepieces:\n";
    	for (int i = 0; i < LIMIT; i++)
    	{
    		cout << "Eyepiece #" << i + 1 << ": ";
    		cin >> eps[i];
    	}
    	file_it(fout, objective, eps, LIMIT);//将目镜数据写入到文件ep-data.txt中
    	file_it(cout, objective, eps, LIMIT);//将目镜数据打印到屏幕上
    	cout << "Done\n";
    	// cin.get();
    	// cin.get();
    	return 0;
    }
    
    void file_it(ostream & os, double fo, const double fe[], int n)
    {
    	// save initial formatting state
    	ios_base::fmtflags initial;
    	initial = os.setf(ios_base::fixed, ios_base::floatfield);
    	std::streamsize sz = os.precision(0);
    	os << "Focal length of objective: " << fo << " mm\n";
    	os.precision(1);
    	os.width(12);
    	os << "f.l. eyepiece";
    	os.width(15);
    	os << "magnification" << endl;//f.l. eyepiece  magnification
    	//30.0             60    30*60=1800(objective)
        //19.0             95     19*95=1805(objective)
    	//14.0            129      14*129=1806(objective)
    	//8.8            205       8.8*205=1806(objective)
    	//7.5            240       7.5*240=1800(objective)
    	for (int i = 0; i < n; i++)
    	{
    		os.width(12);
    		os << fe[i];
    		os.width(15);
    		os << int(fo / fe[i] + 0.5) << endl;
    	}
    	// restore initial formatting state
    	os.setf(initial, ios_base::floatfield);
    	os.precision(sz);
    }

执行结果：

Enter the focal length of your telescope objective in mm: 1800
    Enter the focal lengths, in mm, of 5 eyepieces:
    Eyepiece #1: 30
    Eyepiece #2: 19
    Eyepiece #3: 14
    Eyepiece #4: 8.8
    Eyepiece #5: 7.5
    Focal length of objective: 1800 mm
    f.l. eyepiece  magnification
            30.0             60
            19.0             95
            14.0            129
             8.8            205
             7.5            240
    Done

## left.cpp ##

// left.cpp -- string function with a default argument
    #include <iostream>
    const int ArSize = 80;
    char * left(const char * str, int n = 1);
    int main()
    {
    	using namespace std;
    	char sample[ArSize];
    	cout << "Enter a string:\n";
    	cin.get(sample, ArSize);
    	char *ps = left(sample, 4);//调用left函数 取前四个元素
    	cout << ps << endl;
    	delete[] ps;       // free old string
    	ps = left(sample);//取第一个元素
    	cout << ps << endl;
    	delete[] ps;       // free new string
    	// cin.get();
    	// cin.get();
    	return 0;
    }
    
    // This function returns a pointer to a new string
    // consisting of the first n characters in the str string.
    char * left(const char * str, int n)
    {
    	if (n < 0)
    		n = 0;
    	char * p = new char[n + 1];
    	int i;
    	for (i = 0; i < n && str[i]; i++)
    		p[i] = str[i];  // copy characters
    	while (i <= n)
    		p[i++] = '\0';  // set rest of string to '\0'
    	return p;
    }

执行效果：

Enter a string:
    forthcoming
    fort
    f

## leftover.cpp ##

// leftover.cpp -- overloading the left() function
    #include <iostream>
    unsigned long left(unsigned long num, unsigned ct);
    char * left(const char * str, int n = 1);
    
    int main()
    {
    	using namespace std;
    	const char * trip = "Hawaii!!";   // test value 源代码在这里有错误
    	//需要加上const 否则会报错
    	unsigned long n = 12345678; // test value
    	int i;
    	char * temp;
    
    	for (i = 1; i < 10; i++)
    	{
    		cout << left(n, i) << endl;
    		temp = left(trip, i);
    		cout << temp << endl;
    		delete[] temp; // point to temporary storage
    	}
    	// cin.get();
    	return 0;
    
    }
    
    // This function returns the first ct digits of the number num.
    unsigned long left(unsigned long num, unsigned ct)
    {
    	unsigned digits = 1;
    	unsigned long n = num;
    
    	if (ct == 0 || num == 0)
    		return 0;       // return 0 if no digits
    	while (n /= 10)//12345678/10=1234567
    		digits++;//2
    	if (digits > ct)
    	{
    		ct = digits - ct;
    		while (ct--)
    			num /= 10;//1234567/10=123456
    		return num;         // return left ct digits 123456
    	}
    	else                // if ct >= number of digits
    		return num;     // return the whole number
    }
    
    // This function returns a pointer to a new string
    // consisting of the first n characters in the str string.
    char * left(const char * str, int n)
    {
    	if (n < 0)
    		n = 0;
    	char * p = new char[n + 1];
    	int i;
    	for (i = 0; i < n && str[i]; i++)
    		p[i] = str[i];  // copy characters
    	while (i <= n)
    		p[i++] = '\0';  // set rest of string to '\0'
    	return p;
    }

执行结果：

1
    H
    12
    Ha
    123
    Haw
    1234
    Hawa
    12345
    Hawai
    123456
    Hawaii
    1234567
    Hawaii!
    12345678
    Hawaii!!
    12345678
    Hawaii!!

## funtemp.cpp ##

// funtemp.cpp -- using a function template
    #include <iostream>
    // function template prototype
    template <typename T>  // or class T
    void Swap(T &a, T &b);
    
    int main()
    {
    	using namespace std;
    	int i = 10;
    	int j = 20;
    	cout << "i, j = " << i << ", " << j << ".\n";
    	cout << "Using compiler-generated int swapper:\n";
    	Swap(i, j);  // generates void Swap(int &, int &)
    	cout << "Now i, j = " << i << ", " << j << ".\n";
    
    	double x = 24.5;
    	double y = 81.7;
    	cout << "x, y = " << x << ", " << y << ".\n";
    	cout << "Using compiler-generated double swapper:\n";
    	Swap(x, y);  // generates void Swap(double &, double &)
    	cout << "Now x, y = " << x << ", " << y << ".\n";
    	// cin.get();
    	return 0;
    }
    
    // function template definition
    template <typename T>  // or class T
    void Swap(T &a, T &b)
    {
    	T temp;   // temp a variable of type T
    	temp = a;
    	a = b;
    	b = temp;
    }

执行结果：

i, j = 10, 20.
    Using compiler-generated int swapper:
    Now i, j = 20, 10.
    x, y = 24.5, 81.7.
    Using compiler-generated double swapper:
    Now x, y = 81.7, 24.5.

## twotemps.cpp ##

// twotemps.cpp -- using overloaded template functions
    #include <iostream>
    template <typename T>     // original template
    void Swap(T &a, T &b);
    
    template <typename T>     // new template
    void Swap(T *a, T *b, int n);
    
    void Show(int a[]);
    const int Lim = 8;
    int main()
    {
    	using namespace std;
    	int i = 10, j = 20;
    	cout << "i, j = " << i << ", " << j << ".\n";
    	cout << "Using compiler-generated int swapper:\n";
    	Swap(i, j);              // matches original template
    	cout << "Now i, j = " << i << ", " << j << ".\n";
    
    	int d1[Lim] = { 0,7,0,4,1,7,7,6 };
    	int d2[Lim] = { 0,7,2,0,1,9,6,9 };
    	cout << "Original arrays:\n";
    	Show(d1);//07/04/1776
    	Show(d2);//07/20/1969
    	Swap(d1, d2, Lim);        // matches new template
    	cout << "Swapped arrays:\n";
    	Show(d1);//07/20/1969
    	Show(d2);//07/04/1776
    	// cin.get();
    	return 0;
    }
    
    template <typename T>
    void Swap(T &a, T &b)
    {
    	T temp;
    	temp = a;
    	a = b;
    	b = temp;
    }
    
    template <typename T>
    void Swap(T a[], T b[], int n)
    {
    	T temp;
    	for (int i = 0; i < n; i++)
    	{
    		temp = a[i];
    		a[i] = b[i];
    		b[i] = temp;
    	}
    }
    
    void Show(int a[])
    {
    	using namespace std;
    	cout << a[0] << a[1] << "/";//a[0]=0 a[1]=7
    	cout << a[2] << a[3] << "/";//a[2]=0 a[3]=4
    	for (int i = 4; i < Lim; i++)
    		cout << a[i];//输出a[4]至a[7]
    	cout << endl;
    }

执行结果：

i, j = 10, 20.
    Using compiler-generated int swapper:
    Now i, j = 20, 10.
    Original arrays:
    07/04/1776
    07/20/1969
    Swapped arrays:
    07/20/1969
    07/04/1776

## twoswap.cpp ##

// twoswap.cpp -- specialization overrides a template
    #include <iostream>
    template <typename T>
    void Swap(T &a, T &b);
    
    struct job
    {
        char name[40];
        double salary;
        int floor;
    };
    
    // explicit specialization 
    template <> void Swap<job>(job &j1, job &j2);
    void Show(job &j);
    
    int main()
    {
        using namespace std;
        cout.precision(2);
        cout.setf(ios::fixed, ios::floatfield);
        int i = 10, j = 20;
        cout << "i, j = " << i << ", " << j << ".\n";
        cout << "Using compiler-generated int swapper:\n";
        Swap(i,j);    // generates void Swap(int &, int &)
        cout << "Now i, j = " << i << ", " << j << ".\n";
    
        job sue = {"Susan Yaffee", 73000.60, 7};//struct job
    	//char name[40];
    	//double salary;
    	//int floor;
        job sidney = {"Sidney Taffee", 78060.72, 9};
        cout << "Before job swapping:\n";
        Show(sue);
        Show(sidney);
        Swap(sue, sidney); // uses void Swap(job &, job &)
        cout << "After job swapping:\n";
        Show(sue);
        Show(sidney);
        // cin.get();
        return 0;
    }
    
    template <typename T>
    void Swap(T &a, T &b)    // general version
    {
        T temp;
        temp = a;
        a = b;
        b = temp;
    }
    
    // swaps just the salary and floor fields of a job structure
    
    template <> void Swap<job>(job &j1, job &j2)  // specialization
    {
        double t1;
        int t2;
        t1 = j1.salary;
        j1.salary = j2.salary;
        j2.salary = t1;//交换salary
        t2 = j1.floor;
        j1.floor = j2.floor;
        j2.floor = t2;//交换floor
    }
    
    void Show(job &j)
    {
        using namespace std;
        cout << j.name << ": $" << j.salary
             << " on floor " << j.floor << endl;
    }

执行结果：

i, j = 10, 20.
    Using compiler-generated int swapper:
    Now i, j = 20, 10.
    Original arrays:
    07/04/1776
    07/20/1969
    Swapped arrays:
    07/20/1969
    07/04/1776

## tempover.cpp ##

// tempover.cpp --- template overloading
    #include <iostream>
    
    template <typename T>            // template A
    void ShowArray(T arr[], int n);
    
    template <typename T>            // template B
    void ShowArray(T * arr[], int n);
    
    struct debts
    {
    	char name[50];
    	double amount;
    };
    
    int main()
    {
    	using namespace std;
    	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];
    
    	// set pointers to the amount members of the structures in mr_E
    	for (int i = 0; i < 3; i++)
    		pd[i] = &mr_E[i].amount;
    
    	cout << "Listing Mr. E's counts of things:\n";
    	// things is an array of int
    	ShowArray(things, 6);  // uses template A
    	cout << "Listing Mr. E's debts:\n";
    	// pd is an array of pointers to double
    	ShowArray(pd, 3);      // uses template B (more specialized)
    	// cin.get();
    	return 0;
    }
    
    template <typename T>
    void ShowArray(T arr[], int n)
    {
    	using namespace std;
    	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)
    {
    	using namespace std;
    	cout << "template B\n";
    	for (int i = 0; i < n; i++)
    		cout << *arr[i] << ' ';
    	cout << endl;
    }

执行结果：

>     Listing Mr. E's counts of things:
>     template A
>     13 31 103 301 310 130
>     Listing Mr. E's debts:
>     template B
>     2400 1300 1800

### 删去template B后，得到的结果是： ###

// tempover.cpp --- template overloading
    #include <iostream>
    
    template <typename T>            // template A
    void ShowArray(T arr[], int n);
    
    //template <typename T>            // template B
    //void ShowArray(T * arr[], int n);
    
    struct debts
    {
    	char name[50];
    	double amount;
    };
    
    int main()
    {
    	using namespace std;
    	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];
    
    	// set pointers to the amount members of the structures in mr_E
    	for (int i = 0; i < 3; i++)
    		pd[i] = &mr_E[i].amount;
    
    	cout << "Listing Mr. E's counts of things:\n";
    	// things is an array of int
    	ShowArray(things, 6);  // uses template A
    	cout << "Listing Mr. E's debts:\n";
    	// pd is an array of pointers to double
    	ShowArray(pd, 3);      // uses template B (more specialized)
    	// cin.get();
    	return 0;
    }
    
    template <typename T>
    void ShowArray(T arr[], int n)
    {
    	using namespace std;
    	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)
    //{
    //	using namespace std;
    //	cout << "template B\n";
    //	for (int i = 0; i < n; i++)
    //		cout << *arr[i] << ' ';
    //	cout << endl;
    //}

执行结果：

Listing Mr. E's counts of things:
    template A
    13 31 103 301 310 130
    Listing Mr. E's debts:
    template A
    0093F75C 0093F79C 0093F7DC

## choices.cpp ##

// choices.cpp -- choosing a template
    #include <iostream>
    
    template<class T>
    T lesser(T a, T b)         // #1
    {
    	return a < b ? a : b;
    }
    
    int lesser(int a, int b)  // #2
    {
    	a = a < 0 ? -a : a;
    	b = b < 0 ? -b : b;
    	return a < b ? a : b;
    }
    
    int main()
    {
    	using namespace std;
    	int m = 20;
    	int n = -30;
    	double x = 15.5;
    	double y = 25.9;
    
    	cout << lesser(m, n) << endl;       // use #2 
    	//该函数调用与模板函数和非模板函数都匹配，所以选择非模板函数
    	cout << lesser(x, y) << endl;       // use #1 with double
    	//函数调用与模板匹配(T为double)
    	cout << lesser<>(m, n) << endl;     // use #1 with int
    	//lesser<>(m, n)中<>指出，编译器一个选择模板匹配函数，而不是非模板函数
    	cout << lesser<int>(x, y) << endl; // use #1 with int
    	//进行显式实例化(使用int替代T)将显式实例化得到的函数。x和y被强制转换为int
    	// cin.get();
    	return 0;
    }

执行结果：

20
    15.5
    -30
    15

## 二、复习题 ##

1.哪种函数适合定义为内联函数?

只有一行代码的小型、非递归的函数适合作为内联函数。

2假设song()函数的原形如下:

`void song(const char * name, int times);`

a.如何修改原形,使times的默认值为1?

b.函数定义需要做哪些修改?

c.能否为name提供默认值"O,My Papa"?

a.`void song(const char * name, int times = 1);`

b.函数定义不需要修改，只有函数原型包含默认信息。

c.可以,`void song(char * name ="O,My Papa", int times = 1);`

3.编写iquote()的重载版本--显示其用双引号括起的参数,编写3个版本:一个用于int参数,一个用于double参数,另一个用于string参数。

//用于 int 参数
    void iquote(int n)
    {
        cout << "\"" << n << "\"" << endl;
    }
    //用于 double 参数
    void iquote(couble n)
    {
        cout << "\"" << n << "\"" << endl;
    }
    //用于 string 参数
    void iquote(char * str)
    {
        cout << "\"" << str << "\"" << endl;
    }

4.下面是一个结构模板:

struct box
    {
        char maker[40];
        float height;
        float width;
        float length;
        float volume;
    }

a.请编写一个函数,他将box结构体的引用作为形参,并显示每个成员的值。

b.请编写一个函数，他将box结构的引用作为行参，并将volume成员设置为其他3边的乘积。

void showBox(const box & b)
    {
        cout << "maker : " << b.maker << endl;
        cout << "height : " << b.height <<endl;
        cout << "width : " << b.width << endl;
        cout << "length : " << b.length <<endl;
        cout << "volume : " << b.volume << endl;
    }

void setVolume(box & b)
    {
        b.volume = b.height * b.width * b.length;
    }

5.为让函数fill()和show()使用引用参数,需要对程序清单7.15做哪些修改?

修改后的代码：

#include <iostream>
    #include <array>
    #include <string>
    const int Seasons = 4;
    const std::array<std::string, Seasons> Snames =
        {"Spring", "Summer", "Fall", "Winter"};
    
    void fill(std::array<double, Seasons> &pa);
    void show(const std::array<double, Seasons> &da);
    int main()
    {
        std::array<double, 4> expenses;
        fill(expenses);
        show(expenses);
        return 0;
    }
    
    void fill(std::array<double, Seasons> &pa)
    {
        for (int i = 0; i < Seasons; i++)
        {
            std::cout << "Enter " << Snames[i] << " expenses: ";
            std::cin >> pa[i];
        }
    }
    
    void show(const std::array<double, Seasons> &da)
    {
        double total = 0.0;
        std::cout << "\nEXPENSES\n";
        for (int i = 0; i < Seasons; i++)
        {
            std::cout << Snames[i] << ": $" << da[i] << '\n';
            total += da[i];
        }
        std::cout << "Total: $" << total << '\n';
    }

6.指出下面每个目标是否可以使用默认参数或函数重载完成，或者这两种方法都无法完成，并提供合适的原型。

a. mass(density,volume)返回密度为density、体积为volume的物体的质量，而mass(density)返回密度为density、体积为1.0立法米的物体的质量。这些值的类型都为double。

b. repeat(10,"I'm OK")将指定的字符串显示10次，而repeat("But you're kind of stupid")将指定的字符串显示5次。

c. average(3,6)返回两个int参数的平均值（int类型），而average(3.0,6.0)返回两个double值的平均值（double类型）。

d. mangle("I'm glad to meet you")根据是将值赋给char变量还是char\*变量，分别返回字符1和指向字符串“I'm glad to meet you”的指针。

//既可以使用默认参数，又可以使用函数重载
    //1.默认参数
    double mass(double density, double volume = 1.0);
    
    //2.函数重载
    double mass(double density, double volume);
    double mass(double density);

//不能使用默认参数，因为使用默认值必须从右到左提供默认值
    //函数重载
    void repeat(int times, const char* str);
    void repeat(const char* str);

//函数重载
    int average(int a, int b);
    double average(double a, double b);

d.两种方法都不能完成，需分成两个不同的函数实现。

7.编写返回两个参数中较大值的函数模板。

代码实现：

template<class T>
    T max(T t1, T t2)
    {
        return t1 > t2 ? t1 : t2;
    }

8.给定复习题6的模板和复习题4的box结构，提供一个模板具体化，它接受两个box参数，并返回体积较大的一个。

代码实现：

template<>
    box max(box b1, box b2)
    {
        return b1.volume > b2.volume ? b1 : b2;
    }

9.在下述代码（假定这些代码是一个完整程序的一部分）中，v1、v2、v3、v4和v5分别是哪种类型？

int g(int x);
    
    ....
    
    float m = 5.5f;
    
    float &rm = m;
    
    decltype(m)v1 = m;
    
    decltype(rm)v2 = m;
    
    decltype((m)) v3 = m;
    
    decltype(g(100))v4;
    
    decltype(2.0*m)v5;

decltype(m)v1 = m;     //类型为float
    decltype(rm)v2 = m;    //类型为float &
    decltype((m)) v3 = m;  //类型为float &
    decltype(g(100))v4;    //类型为int
    decltype(2.0*m)v5;     //类型为double

## 三、编程练习 ##

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

代码实现:

#include<iostream>
    
    using namespace std;
    
    int myShowStr(char* str, int printTimes);
    
    int main()
    {
        char mystr[50] = "Hello,world!";
        myShowStr(mystr, 5);
        return 0;
    }
    
    int myShowStr(char* str, int printTimes)
    {
        if(printTimes > 1)
        {
            cout << str << endl;
            printTimes--;
            myShowStr(str, printTimes);
        }
        else
        {
            cout << str << endl;
        }
        return printTimes;
    }

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

代码实现:

#include<iostream>
    using namespace std;
    #define DEFAULT_BRAND  (char*)"Millennium Munch"
    struct CandyBar{
        char* brand;
        double weight;
        int heat;
    };
    void setCandyBar(CandyBar& candyBar, char* brand = DEFAULT_BRAND, double weight = 2.85, int heat = 350);
    void display(const CandyBar& candyBar);
    
    int main()
    {
        CandyBar cb,cb1;
        setCandyBar(cb1);
        setCandyBar(cb, (char*)"MJJ", 3.55, 120);
        display(cb);
        display(cb1);
        return 0;
    }
    
    void setCandyBar(CandyBar& candyBar, char *brand, double weight, int heat)
    {
        candyBar.brand = brand;
        candyBar.weight = weight;
        candyBar.heat = heat;
    }
    
    void display(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`  
`Enter a string (q to quit):good grief!`  
`GOOD GRIEF!`  
`Enter a string (q to quit):q`  
`Bye.`

代码实现:

#include<iostream>
    #include<string>
    using namespace std;
    void Conversion(string& str);
    int main()
    {
        string str;
        cout<<"Enter a string(q to quit): ";
        while(getline(cin,str) && str != "q")
        {
            Conversion(str);
            cout << str << endl;
            cout << "Next string(q to quit): ";
        }
        cout << "Bye." << endl;
        return 0;
    }
    
    void Conversion(string& str)
    {
        int size = str.size();
        for(int i =0; i < size; i++)
        {
            str[i] = toupper(str[i]);
        }
    }

4.下面是一个程序框架：

#include<iostream>
    #include<cstring>
    using namespace std;
    
    struct stringy{
        char * str;
        int ct;
    };
    
    int main()
    {
        stringy beany;
        char testing[] = "Reality isn't what it used to be.";
        set(beany, testing);
        show(beany);
        show(beany, 2);
        testing[0] = 'D';
        testing[1] = 'u';
        show(testing);
        show(testing, 3);
        show("Done!");
    
        return 0;
    }

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

代码实现：

#include<iostream>
    #include<cstring>
    using namespace std;
    
    struct stringy{
        char * str;
        int ct;
    };
    
    void set(stringy& stry, const char* test);
    void show(const stringy& stry, int showTimes = 1);
    void show(const char* ch, int showTimes = 1);
    int main()
    {
        stringy beany;
        char testing[] = "Reality isn't what it used to be.";
        set(beany, testing);
        show(beany);
        show(beany, 2);
        testing[0] = 'D';
        testing[1] = 'u';
        show(testing);
        show(testing, 3);
        show("Done!");
    
        return 0;
    }
    
    void set(stringy& stry, const char* test)
    {
        stry.ct = strlen(test);
        stry.str = new char[stry.ct];
        strcpy(stry.str, test);
    }
    
    void show(const stringy& stry, int showTimes)
    {
        for(int i =0; i < showTimes; i++)
        {
            cout << stry.str <<endl;
        }
    }
    
    void show(const char* ch, int showTimes)
    {
        for(int i =0; i < showTimes; i++)
        {
            cout << ch <<endl;
        }
    }

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

代码实现：

#include<iostream>
    
    using namespace std;
    
    template<typename T>
    T max5(T *t);
    
    int main()
    {
        int arr1[5] = {5, 3, 5, 9, 6};
        double arr2[5] = {5.2, 3.1, 6.8, 10.8, 7.1};
        cout << "arr1 max num : " << max5(arr1) << endl;
        cout << "arr2 max num : " << max5(arr2) << endl;
        return 0;
    }
    
    template<typename T>
    T max5(T* t)
    {
        T maxValue = t[0];
        for(int i = 1; i < 5; i++)
        {
            if(maxValue < t[i])
            {
                maxValue = t[i];
            }
        }
        return maxValue;
    }

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

代码实现：

#include<iostream>
    #include<cstring>
    
    using namespace std;
    
    template<typename T>
    T maxn(T* t, int n);
    
    template<>
    char* maxn(char* pch[], int n);
    
    int main()
    {
        int arr1[6] = {5, 3, 5, 9, 6, 11};
        double arr2[4] = {5.2, 3.1, 2.8, 4.8};
        char const * arr3[5] = {
            "abcde",
            "abcdef",
            "abc",
            "ab",
            "abcdefg"
        };
        cout << "arr1 max num : " << maxn(arr1, 6) << endl;
        cout << "arr2 max num : " << maxn(arr2, 4) << endl;
        cout << "arr3 max len : " << maxn(arr3, 5) << endl;
        return 0;
    }
    
    template<typename T>
    T maxn(T* t, int n)
    {
        T maxValue = t[0];
        for(int i = 1; i < n; i++)
        {
            if(maxValue < t[i])
            {
                maxValue = t[i];
            }
        }
        return maxValue;
    }
    
    template<>
    char* maxn(char* pch[], int n)
    {
        auto maxLen = strlen(pch[0]);
        int index = 0;
        for(int i = 1; i < n; i++)
        {
            if(maxLen < strlen(pch[i]))
            {
                maxLen = strlen(pch[i]);
                index = i;
            }
        }
        return pch[index];
    }

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

>     /******************程序清单8.14******************/
>     // tempover.cpp --- template overloading
>     #include <iostream>
>     
>     template <typename T>            // template A
>     void ShowArray(T arr[], int n);
>     
>     template <typename T>            // template B
>     void ShowArray(T * arr[], int n);
>     
>     struct debts
>     {
>         char name[50];
>         double amount;
>     };
>     
>     int main()
>     {
>         using namespace std;
>         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]; 
>     
>     // set pointers to the amount members of the structures in mr_E
>         for (int i = 0; i < 3; i++)
>             pd[i] = &mr_E[i].amount;
>     
>         cout << "Listing Mr. E's counts of things:\n";
>     // things is an array of int
>         ShowArray(things, 6);  // uses template A
>         cout << "Listing Mr. E's debts:\n";
>     // pd is an array of pointers to double
>         ShowArray(pd, 3);      // uses template B (more specialized)
>         // cin.get();
>         return 0;
>     }
>     
>     template <typename T>
>     void ShowArray(T arr[], int n)
>     {
>         using namespace std;
>         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)
>     {
>         using namespace std;
>         cout << "template B\n";
>         for (int i = 0; i < n; i++)
>             cout << *arr[i] << ' ';
>         cout << endl; 
>     }

代码实现：

#include <iostream>
    
    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()
    {
        using namespace std;
        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 << "sum of things : " << SumArray(things, 6) << endl;
        cout << "sum of debts :" << SumArray(pd, 3) << endl;;
    
        return 0;
    }
    
    template <typename T>
    T SumArray(T arr[], int n)
    {
        T sum = 0;
        for(int i =0; i < n; i++)
        {
            sum = sum + arr[i];
        }
        return sum;
    }
    
    template <typename T>
    T SumArray(T * arr[], int n)
    {
        T sum = 0;
        for(int i =0; i < n; i++)
        {
            sum = sum + *arr[i];
        }
        return sum;
    }

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA6ZW_5rKZ5pyJ6IKl6bG8_size_20_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6efbdbb72c40491082a5bdabf1cd7904.png