C++ Primer Plus (第6版) 中文版第八章函数探幽编程练习答案

69 阅读 0 评论 46 点赞

我是靠谱客的博主稳重指甲油，最近开发中收集的这篇文章主要介绍C++ Primer Plus (第6版) 中文版第八章函数探幽编程练习答案，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

第八章编程练习
1.编写通常接受一个参数（地址），并打印该字符串的函数。然而，如果提供了第二个参数（不为0），则该函数打印字符串的次数将为该函数被调用的次数。次数不等于第二个参数的值，而等于函数被调用的次数。

//编写通常接受一个参数（地址），并打印该字符串的函数。然而，如果提供了第二个参数（不为0），则该函数打印字符串的次数将为该函数被调用的次数
//次数不等于第二个参数的值，而等于函数被调用的次数。
#include<iostream>
void print(char * str ,int n=0);
int main()
{
 using namespace std;
 char str[20];
 int n;
 cout<<"Enter string:"<<endl;
 cin.get(str,20).get();
 cout<<"Enter a int(int !=0):"<<endl;
 if (cin>>n)
 {
  cout<<"Enter string or int:"<<endl;
  print(str,n);
 }
 else
 {
  cout<<"Only enter string:"<<endl;
  print(str);
 }
 cin.get();
 cin.get();
 return 0;
}
void print(char *str,int n)
{
 using namespace std;
 if (n !=0)
 {
  print(str,n-1);
 }
 cout<<"第 "<<n+1<<" 次调用print函数："<<"t"<<str<<endl;
}

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

//CandyBar结构包含3个成员。第一个成员存储品牌名称；第二个存储重量（可能有小数点）；第三个存储热量（整数）。
//编写一个程序，它使用一个这样的函数，即将CandyBar的引用、char指针、double和int作为参数，并用最后三个值设置相应的结构成员。
//最后三个参数的默认值分别为“Millennium Munch”、2.85和350.另外，该程序还包含一个以CandyBar的引用为参数，并显示结构内容的函数。
//请尽可能使用const。
#include<iostream>
#include<cstring>
using namespace std;
struct CandyBar
{
 char band[25];
 double weight;
 int calorie;
};
char init_band[25] = "Millennium Munch";
void setting(CandyBar & cb,const char * band=init_band,const double weight=2.85,int calorie=350);
void show(const CandyBar & cb);
int main()
{
 CandyBar cb;
 char input_band[25];
 double input_weight;
 int input_calorie;
 setting(cb);
 cout<<"设置默认值为：n";
 show(cb);
 cout<<"请输入品牌名称:";
 cin.get(input_band,25).get();
 cout<<"请输入品牌重量:";
 cin>>input_weight;
 cout<<"请输入品牌热量:";
 cin>>input_calorie;
 setting(cb,input_band,input_weight,input_calorie);
 show(cb);
 setting(cb);
 cout<<"再次设置默认值为：n";
 show(cb);
 cin.get();
 cin.get();
 return 0;
}
void setting(CandyBar & cb,const char * band,const double weight,int calorie)
{
 strcpy(cb.band,band);
 cb.weight=weight;
 cb.calorie=calorie;
}
void show(const CandyBar & cb)
{
 cout<<"当前品牌的名称为："<<cb.band<<endl;
 cout<<"当前品牌的重量为："<<cb.weight<<endl;
 cout<<"当前品牌的热量为："<<cb.calorie<<endl;
}

3.编写一个程序，它接受一个指向string对象的引用作为参数，并将该string对象的内容转换为大写（可以使用toupper函数）。编写一个程序，它通过使用一个循环让您能够用不同的输入来测试这个函数。

//编写一个程序，它接受一个指向string对象的引用作为参数，并将该string对象的内容转换为大写（可以使用toupper函数）
//编写一个程序，它通过使用一个循环让您能够用不同的输入来测试这个函数。
#include<iostream>
#include<string>
#include<cctype>
using namespace std;
void upper(string & str);
int main()
{
 string str;
 cout<<"Enter a string (q to quit):";
 getline(cin,str);
 while(((str[0] !='q')&&(str.size()==1)) || (str.size()!=1))
 {
  upper(str);
  cout<<str<<endl;
  cout<<"Next string (q to quit):";
  getline(cin,str);
 }
 cout<<"Byb.";
 cin.get();
 return 0;
}
void upper(string & ttt)
{
 for (int i=0;i<ttt.size();i++)
  ttt[i]=toupper(ttt[i]);
}

4.给了一个框架，提供这个框架描述的函数和原型。应用两个show（）函数，每个都使用默认参数。尽可能使用const参数。set（）使用new分配足够的空间来存储指定的字符串。这里使用的技术与设计和实现类时使用的相似。

//给了一个框架，提供这个框架描述的函数和原型。
//应用两个show（）函数，每个都使用默认参数。尽可能使用const参数。
//set（）使用new分配足够的空间来存储指定的字符串。这里使用的技术与设计和实现类时使用的相似。
#include<iostream>
using namespace std;
#include<cstring>                      //for strlen(),strcpy
struct stringy{
 char * str;                        //points to a string
 int ct;                            //length of string (not counting '')
};
//prototypes for set(),show(),and show() go here
void set(stringy & stry,const char *str);
void show(const stringy & stry,int n=1);
void show(const char *str,int n=1);
int main()
{
 stringy beany;
 char testing[]="Reality isn't what it used to be.";
 set(beany,testing); //first argument is a reference,
                    //allocates space to hold copy of testing,
                    //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 twice
 show("Done!");
 cin.get();
 return 0;
}
void set(stringy & stry,const char *str)
{
 stry.str=new char[strlen(str)+1];
 strcpy(stry.str,str);
 stry.ct=strlen(str)+1;
}
void show(const stringy & stry,int n)
{
 for (int i=0;i<n ;i++)
  cout<<stry.str<<endl;
 cout<<endl;
}
void show(const char *str,int n)
{
 for (int i=0;i<n ;i++)
  cout<<str<<endl;
 cout<<endl;
}

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

//编写模板函数max5（），它将一个包含5个T类元素的数组作为参数，并返回数组中最大的元素/
//由于长度固定，因此可以在循环中使用硬编码，而不必通过参数来传递。
//在一个程序中使用该函数，将T 替换为一个包含5个int值的数组和一个包含5个double值的数组，以测试该函数。
#include<iostream>
template <typename T>
T max5(T arr[]);
using namespace std;
int main()
{
 int int_arr[5]={5,10,15,20,25};
 double double_arr[5]={5.5,10.10,15.15,20.20,25.25};
 cout<<"int数组中元素的最大值为："<<max5(int_arr)<<endl;
 cout<<"double数组中元素的最大值为："<<max5(double_arr)<<endl;
 cin.get();
 return 0 ;
}
template <typename T>
T max5(T arr[])
{
 T a=arr[0];
 for (int i=0;i<5;i++)
 {
  if (a<arr[i])
   a=arr[i];
 }
 return a;
}

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

//编写模板函数maxn（），它将一个包含5个T类元素的数组和一个表示数组元素数目的整数作为参数，并返回数组中最大的元素
//编写程序对它进行测试，该程序使用一个包含6个int元素的数组和一个包含4个double元素的数组来调用该函数。
//程序还包含一个具体化，它将char指针数组和数组中的指针数量作为参数，并返回最长的字符串的地址。
//如果有多个这样的字符串，则返回其中第一个字符串的地址。使用由5个字符串指针组成的数组来测试该具体化。
#include<iostream>
template<typename T>
T maxn(T arr[],int n);
template<>const char * maxn(const char *arr[],int n);
int main()
{
 using namespace std;
 int int_arr[6]={5,10,15,20,25,30};
 double double_arr[4]={5.5,6.6,7.7,8.8};
 const char *str_arr1[5]={"a","ab","abc","abcd","abcde"};
 const char *str_arr2[5]={"a","ab","aaaaa","abcd","abcde"};
 cout<<maxn(int_arr,6)<<endl;
 cout<<maxn(double_arr,4)<<endl;
 cout<<maxn(str_arr1,5)<<endl;
 cout<<maxn(str_arr2,5)<<endl;
 cin.get();
 return 0;
}
template<typename T>
T maxn(T arr[],int n)
{
 T a = arr[0];
 for(int i=1;i<n;i++)
 {
  if (a<arr[i])
   a=arr[i];
 }
 return a;
}
template<>const char *maxn(const char *arr[],int n)
{
 const char * a = arr[0];
 for(int i=1;i<n;i++)
 {
  if(strlen(a)<strlen(arr[i]))
   a=arr[i];
 }
 return a;
}

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

//修改程序清单8.14，使其使用两个名为SumArray（）的模板函数来返回数组元素的总和，而不是显示数组的内容。
//程序应显示thing的总和以及所有debt的总和。
// tempover.cpp --- template overloading
#include <iostream>
template <typename T>            // template A
void SumArray(T arr[], int n);
template <typename T>            // template B
void 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]; 
// 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
    SumArray(things, 6);  // uses template A
    cout << "Listing Mr. E's debts:n";
// pd is an array of pointers to double
    SumArray(pd, 3);      // uses template B (more specialized)
    cin.get();
    return 0;
}
template <typename T>
void SumArray(T arr[], int n)
{
    using namespace std;
    T sum=0;
 cout << "template An";
    for (int i = 0; i < n; i++)
  sum =sum+arr[i];
    cout <<sum<< endl;
}
template <typename T>
void SumArray(T * arr[], int n)
{
    using namespace std;
    T sum=0;
 cout << "template Bn";
    for (int i = 0; i < n; i++)
        sum =sum+ *arr[i];
    cout <<sum<< endl; 
}