c++ Primer 第六章：函数 练习答案记录
练习题导航
- c++ Primer 第六章：函数 练习答案记录
- 6.1 函数基础
- 6.2 参数传递
- 6.2.1 传值参数
- 6.2.2 传引用参数
- 练习6.11 编写并验证你自己的reset函数，使其作用于引用类型的参数
- 练习6.12 改写6.2.1节中练习6.10（第188页）的程序，使用引用而非指针交换两个整数的值。你觉得哪种方法更易于使用呢？为什么？
- 练习6.13 假设T是某种类型的名字，说明以下两个函数声明的区别：一个是void f(T)，另一个是void f(&T)
- 练习6.14 举一个形参应该是引用类型的例子。再举一个形参不能是引用类型的例子
- 练习6.15 find_char函数中的三个形参为什么是现在的类型，特别说明为什么s是常量引用而occurs是普通引用？为什么s和occurs是引用类型而c不是？如果令s是普通引用会发生什么情况？如果令occurs是常量引用又会发生什么情况？
- 6.2.3 const形参和实参
- 6.2.4 数组形参
- 6.2.5 main:处理命令行选项
- 6.2.6 含有可变形参的函数
- 6.3 返回类型和return语句
- 6.4 函数重载
- 6.5 特殊用途语言特性
- 6.6 函数匹配
- 6.7 函数指针
下面的练习别忘记都加上下面这一语句
#include<iostream>
6.1 函数基础
练习6.1 实参和形参的区别是什么？
实参是形参的初始值。第一个实参初始化第一个形参，第二个实参初始化第二个形参，以此类推。
实参的类型必须与对应的形参类型相匹配，这一点与之前的规则是一致的，我们知道在初始化过程中初始值的类型也必须与初始化对象的类型匹配
练习6.2 请指出下列函数哪个有错误，为什么？应该如何修改这些错误呢？
#include<string>
using namespace std;
string f();
void f2(int i);
int calc(int v1, int v2);
double square(double x);
//(a)修改后 =》返回类型为int，但是实际返回了字符串
string f() {
string s;
return s;
}
//(b)修改后 =》需要加上函数的声明
void f2(int i) {
}
//(c)修改后 =》两形参的名字不能相同
int calc(int v1, int v2) {
}
//(d)修改后 =》应该定义块
double square(double x) {
return x * x;
}
练习6.3 编写你自己的fact函数，上机检查是否正确
练习6.4 编写一个与用户交互的函数，要求用户输入一个数字，计算生成该数字的阶乘。在main函数中调用该函数。
int fact(int n);
using namespace std;
int fact(int n)
{
int sum = 1;
for (n; n > 0; n--) {
sum = sum * n;
}
return sum;
}
int main()
{
int n, output;
cout << "请输入所需要求得阶乘数：" << endl;
cin >> n;
output = fact(n);
cout << "阶乘结果是：" << output << endl;
return 0;
}
练习6.5 编写一个函数输出起始参的绝对值
using namespace std;
int fact(int n)
{
n = -n;
return n;
}
int main()
{
int i;
cout << "输出起始参的绝对值" << endl;
cin >> i;
if (i < 0) {
i = fact(i);
}
cout << "绝对值为：" << i << endl;
}
6.1.1 局部对象
练习6.6 说明形参、局部变量以及局部静态变量的区别，编写一个函数，同时用到这三种形式
形参和函数体内部定义的变量统统称为局部变量，它们对函数而言是“局部的”，仅在函数的作用域内可见，同时局部变量还会隐藏在外层作用域中同名的其他声明中
局部静态对象在程序的执行路径第一次经过对象定义语句时初试化，并且直到程序终止才被销毁，再次期间即使对象所在的函数结束执行也不会对它有影响
using namespace std;
int fact(int n) //n是形参
{
static int m = 0; //m是局部静态变量
m = m + n;
return m;
}
int main()
{
int input;
cout << "输入所加数：(3次）" << endl;
for (int i = 0; i < 3; i++) { //i是局部变量
cin >> input;
input = fact(input);
cout << "相加结果：" << input << endl;
}
}
练习6.7 编写一个函数，当它第一次被调用时返回0，以后每次被调用返回值加1
using namespace std;
int fact() //n是形参
{
static int m = -1; //m是局部静态变量
++m;
return m;
}
int main()
{
int input;
while (cin>>input) {
cout <<"被调用："<< fact() << endl;
}
}
6.1.2 函数声明
练习6.8 编写一个名为Chapter6.h的头文件，令其包含6.1节练习（第184页）中的函数声明
点左边源文件按右键，选择新建项，选择头文件类型
#pragma once
#ifndef SALES_DATA_H //头文件保护符
#define SALES_DATA_H
#include<string>
#include<iostream>
#include<vector>
int fact() //n是形参
{
static int m = -1; //m是局部静态变量
++m;
return m;
}
#endif
6.1.3 分离式编译
练习6.9 编写你自己的fact.cc和factMain.cc，这两个文件都应该包含上一小节的练习中编写的Chapter6.h头文件。通过这些文件，理解你的编译器是如何支持分离式编译的
#include"Chapter6.h"
using namespace std;
int main()
{
int input;
while (cin >> input) {
cout << "被调用：" << fact() << endl;
}
}
6.2 参数传递
6.2.1 传值参数
练习6.10 编写一个函数，使用指针形参交换两个整数的值。在代码中调用该函数并输出交换后的结果，以此验证函数的正确性。
void exchange(int* p1, int* p2);
using namespace std;
void exchange(int* p1, int* p2)
{
int a;
a = *p1;
*p1 = *p2;
*p2 = a;
}
int main()
{
int input1, input2;
cout << "请输入所要交换的两个整数：" << endl;
cin >> input1 >> input2;
int* p1 = &input1, * p2 = &input2;
exchange(p1, p2);
cout << "交换后：" << *p1 <<" " << *p2 << endl;
}
6.2.2 传引用参数
练习6.11 编写并验证你自己的reset函数，使其作用于引用类型的参数
void reset(int& i);
using namespace std;
void reset(int& i)
{
i = 0;
}
int main()
{
int j = 10;
reset(j);
cout << j << endl;
}
练习6.12 改写6.2.1节中练习6.10（第188页）的程序，使用引用而非指针交换两个整数的值。你觉得哪种方法更易于使用呢？为什么？
void exchange(int& i, int& j);
using namespace std;
void exchange(int& i, int& j)
{
int a;
a = i;
i = j;
j = a;
}
int main()
{
int input1, input2;
cout << "请输入所要交换的两个整数：" << endl;
cin >> input1 >> input2;
exchange(input1, input2);
cout << "交换后：" << input1 << " " << input2 << endl;
}
练习6.13 假设T是某种类型的名字，说明以下两个函数声明的区别：一个是void f(T)，另一个是void f(&T)
void f(T)，不改变T void f(&T)，对T实参可以改变
练习6.14 举一个形参应该是引用类型的例子。再举一个形参不能是引用类型的例子
这里参考了其他人的做法，链接转向：
https://blog.csdn.net/shamozhizhoutx/article/details/82263038
应该是引用的例子:
void reset(int& i)
{
i = 0;
}
不能是引用的例子:
void print(std::vector<int>::iterator begin, std::vector<int>::iterator end)
{
for (std::vector<int>::iterator iter = begin; iter != end; ++iter)
std::cout << *iter << std::endl;
}
练习6.15 find_char函数中的三个形参为什么是现在的类型，特别说明为什么s是常量引用而occurs是普通引用？为什么s和occurs是引用类型而c不是？如果令s是普通引用会发生什么情况？如果令occurs是常量引用又会发生什么情况？
1、为什么s是常量引用而occurs是普通引用：因为我们不需要改变s里面的值，所以s是常量引用，而希望改变occurs并返回到实参所以使用普通引用
2、为什么s和occurs是引用类型而c不是：c并不需要改变，所以不用引用
3、如果令s是普通引用会发生什么情况：可能会改变s的值，并且这个函数只能作用于string对象，类似调用find_char(“Hello World”)就会发生错误
4、如果令occurs是常量引用又会发生什么情况：那么将不会完成计数的功能，occurs不会改变，反而会报错
6.2.3 const形参和实参
练习6.16 下面的这个函数虽然合法，但是不算特别有用。指出它的局限性并设法改善
#include<string>
using namespace std;
bool is_empty(string& s) {
return s.empty();
}
如果无需改变s，那么加个const更好
bool is_empty(const string& s) {
return s.empty();
}
练习6.17 编写一个函数，判断string对象中是否含有大写字母。编写另一个函数，把string对象全部改写成小写形式。在这两个函数中你使用的形参类型相同吗？为什么？
不相同，判断string对象中是否含有大写字母使用的const型，因为不需要改变string对象，而把string对象全部改写成小写形式不使用const
#include<string>
#include<vector>
using namespace std;
bool think(const string& s);
void xiaoxie(string& s);
bool think(const string& s)
{
int a = 0;
for (auto i = s.begin(); i < s.end(); ++i) {
if (*i == toupper(*i)) {
return 1; //有大写字母返回true
break;
}
++a;
}
if (a == s.size()) { //如果没有大写字母那就返回fasle
return 0;
}
}
void xiaoxie(string& s)
{
for (auto i = s.begin(); i < s.end(); ++i) {
if (*i == toupper(*i)) {
*i = tolower(*i);
}
}
}
int main()
{
string s1 = "Hello World", s2 = "aaaaaa";
if (think(s1)) {
cout << "s1有大写字母" << endl;
xiaoxie(s1);
cout << "全变为小写后：" << s1 << endl;
}
else {
cout << "s1没有大写字母" << endl;
}
if (think(s2)) {
cout << "s2有大写字母" << endl;
xiaoxie(s1);
cout << "全变为小写后：" << s1 << endl;
}
else {
cout << "s2没有大写字母" << endl;
}
}
练习6.18 为下面的函数编写函数声明，从给定的名字中推测函数具备的功能
(a)名为compare的函数，返回布尔值，两个参数都是matrix类的引用
bool compare(matrix& a, matrix& b) {
return true;
//return false;
}
(b)名为change_val的函数，返回vector的迭代器，有两个参数：一个int，另一个是vector的迭代器
#include<vector>
vector<int>::iterator change_val(int i,vector<int>::iterator j)
练习6.19 假定有如下声明，判断哪个调用合法、哪个调用不合法。对于不合法的函数调用，说明原因。
#include<vector>
#include<string>
using namespace std;
double calc(double );
int count(const string& , char);
int sum(vector<int>::iterator , vector<int>::iterator , int );
vector<int> vec(10);
int main()
{
calc(23.4, 55.1); //错误，只能有一个形参
count("abcda", 'a'); //对
calc(66); //对
sum(vec.begin(), vec.end(), 3.8); //对
}
练习6.20 引用形参什么时候应该是常量引用？如果形参应该是常量引用，而我们将其设成了普通引用，会发生什么情况？
把函数不会改变的形参定义成（普通的）引用是一种比较常见的错误，这么做带给函数的调用者一种误导，即函数可以修改它的实参的值。
就比如string::size_type find_char(string &s,char c,string::size_type
&occurs);
则只能将find_char函数作用与string对象，类似find_char(“Hello”,‘o’,ctr);将在编译时发生错误
6.2.4 数组形参
练习6.21 编写一个函数，令其接受两个参数：一个是int型的数，另一个是int指针。函数比较int的值和指针所指的值，返回较大的那个。在该函数中指针的类型应该是是什么？
#include<vector>
#include<string>
using namespace std;
int compare(int i, int* j);
int compare(int i, int* j)
{
if (i > *j) {
return i;
}
else {
return *j;
}
}
int main()
{
int i, k = 0;
int* j = &k;
cout << "输入两个数比较大小：" << endl;
cin >> i >> *j;
i = compare(i, j);
cout << "较大的数是：" << i << endl;
}
练习6.22 编写一个函数，令其交换两个int指针
#include<vector>
#include<string>
using namespace std;
void exchange(int* a, int* b);
void exchange(int* a, int* b)
{
int i = 0;
i = *b;
*b = *a;
*a = i;
}
int main()
{
int i = 1, j = 2;
exchange(&i, &j);
cout << i << " " << j << endl;
}
练习6.23 参考本节介绍的几个print函数，根据理解编写你自己的版本。依次调用每个函数使其输入下面定义的i和j：
#include<vector>
#include<string>
using namespace std;
void print(int i, const int j[], size_t size);
void print1(int i, const int(&j)[2]);
void print(int i, const int j[], size_t size)
{
cout << j[0] <<" " << j[1] << endl;
}
void print1(int i, const int(&j)[2])
{
for (auto i : j) {
cout << j[i] << " ";
}
cout << endl;
}
int main()
{
int i = 0;
int j[2] = { 0,1 };
print(i, j, size(j));
print1(i, j);
}
练习6.24 描述下面这个函数的行为。如果代码中存在问题，请指出并改正。
该函数传递的不是数组是const int*，如果实参不是含10个元素的int数组，可能导致for循环数组越界,下面为修改后
using namespace std;
void print(const int(&ia)[10])
{
for (size_t i = 0; i != 10; ++i)
cout << ia[i] << endl;
}
6.2.5 main:处理命令行选项
练习6.25 编写一个main函数，令其接受两个实参。把实参的内容连接成一个string对象并输出出来
int main(int argc, char const* argv[])
{
for (int i = 0; i != argc; ++i) {
std::cout << argv[i] << std::endl;
}
}
练习6.26 编写一个程序，使其接受本节所示的选项；输出传递给main函数的实参的内容
首先对程序文件右键，选择最底下属性
点调试，点命令参数，输入prog -d -o ofile data0
int main(int argc, char const* argv[])
{
for (int i = 0; i != argc; ++i) {
std::cout << argv[i] << std::endl;
}
}
6.2.6 含有可变形参的函数
练习6.27 编写一个函数，它的参数是initializer_list类型的对象，函数的功能是计算列表中所有元素的和
#include<initializer_list>
#include<vector>
#include<string>
using namespace std;
int sum(initializer_list<int> i);
int sum(initializer_list<int> i)
{
int sum = 0;
for (auto j : i) {
sum += j;
}
return sum;
}
int main()
{
initializer_list<int> i({ 0,1,2,3,4,5 });
int output = sum(i);
cout << output << endl;
}
练习6.28 在error_msg函数的第二个版本中包含ErrCode类型的参数，其中循环内的elem是什么类型？
const std::string&类型
练习6.29 在范围for循环中使用initializer_list对象时，应该将循环控制变量声明成引用类型吗？为什么？
不用，因为initializer_list对象中的元素永远是常量值，无法改变，或者数据量大的时候可以使用引用
6.3 返回类型和return语句
6.3.1 无返回值函数
6.3.2 有返回值函数
练习6.30 编译第200页的str_subrange函数，看看你的编译器是如何处理函数中的错误的
#include<string>
#include<vector>
#include<initializer_list>
using namespace std;
bool str_subrange(const string& str1, const string& str2);
bool str_subrange(const string& str1, const string& str2)
{
if (str1.size() == str2.size())
return str1 == str2;
auto size = (str1.size() < str2.size()) ? str1.size() : str2.size();
for (decltype(size)i = 0; i != size; i++) {
if (str1[i] != str2[i])
return; //错误：“str_subrange”: 函数必须返回值
}
}
练习6.31 什么情况下返回的引用无效？什么情况下返回常量的引用无效？
1、返回的引用时局部对象的引用
2、返回的常量引用是局部常量对象的引用时
练习6.32 下面的函数合法吗？如何合法，说明其功能；如果不合法，修改其中的错误并解释原因。
合法，并且返回了数组ia从0到9
#include<string>
#include<vector>
#include<initializer_list>
using namespace std;
int& get(int* arry, int index)
{
return arry[index];
}
int main()
{
int ia[10];
for (int i = 0; i != 10; i++) {
get(ia, i) = i;
cout << ia[i] << endl;
}
}
练习6.33 编写一个递归函数，输出vector对象的内容
#include<string>
#include<vector>
using namespace std;
size_t a(vector<int> b, size_t i)
{
if (i != 0) { //只要i不等于0就继续迭代，直到找到i=0，输出b【0】
--i;
i = a(b, i);
}
cout << b[i] << endl;
return ++i;
}
int main()
{
vector<int> b = { 0,1,2,3,4 };
size_t i = b.size();
a(b, i-1); //因为b是从0开始计数，所以i要减1
}
练习6.35 在调用factorial函数时，为什么我们传入的值是val-1而非val–？
因为val–，是先传入val，再对val本身做减法，这里用val-1或者–val都可以
6.3.3 返回数组指针
练习6.36 编写一个函数的声明。使其返回数组的引用并且该数组包含10个string对象。不要使用尾置返回类型、decltype或者类型别名
#include<string>
using namespace std;
string(&fu(string(&s)[10]))[10];
练习6.37 为上一题的函数再写三个声明，一个使用类型别名，另一个使用尾置返回类型，最后一个使用decltype关键字。你觉得哪种形式最好？为什么？
#include<string>
using namespace std;
string Ar[10];
typedef string arr[10];
arr& fu(arr& s); //类型别名
using Arr = string[10];
Arr& Fu(Arr& s); //类型别名
auto FUU(string(&s)[10])->string(&)[10]; //尾置返回类型
decltype(Ar)& Fu(decltype(Ar)& arr);
练习6.38 修改arrptr函数，使其返回数组的引用
#include<string>
#include<vector>
using namespace std;
int odd[] = { 1,3,5,7,9 };
int even[] = { 0,2,4,6,8 };
decltype(odd)& arrptr(int i);
decltype(odd)& arrptr(int i)
{
return (i % 2) ? odd : even;
}
6.4 函数重载
练习6.39 说明在下面的每组声明中第二条声明语句是何含义。如果有非法的声明，请指出来
#include<string>
#include<vector>
using namespace std;
//(a）
int calc(int, int);
int calc(const int, const int); //重复声明了int calc(int, int)
//(b)
int get();
double get(); //错误：与上一个函数相比只有返回类型不同
//(c)
int* reset(int*);
double* reset(double*); //合法
6.4.1 重载与作用域
6.5 特殊用途语言特性
6.5.1 默认实参
练习6.40 下面的哪个声明是错误的？为什么？
//(a)
int ff(int a, int b = 0, int c = 0); //合法
//(b)
char* init(int ht = 24, int wd, char bckgrnf); //错误：默认实参不在形参列表的结尾
练习6.41 下面的哪个调用是非法的？为什么？哪个调用虽然合法但显然与程序员的初衷不符？为什么？
char* init(int ht, int wd = 80, char bckgrnd = ' ');
//(a)
init(); //错误：函数第一个形参没有默认实参，必须给实参
//(b)
init(24, 10); //合法
//(c)
init(14, '*'); //合法，但与初衷不符，char '*'转换成整形了
练习6.42 给make_plural函数（参见6.3.2节，第201页）的第二个形参赋予默认实参’s’，利用新版本的函数输出单词success和failure的单数和复数形式
#include<string>
using namespace std;
string make_plural(size_t ctr, const string& word, const string& ending = "s")
{
return (ctr > 1) ? word + ending : word;
}
int main()
{
cout << make_plural(2, "zzzz", "nnn") << endl;
cout << make_plural(2, "111") << endl;
}
6.5.2 内联函数和constexper函数
练习6.43 你会把下面的哪个声明和定义放在头文件中？哪个放在源文件中？为什么？
(a)放头文件，因为对于某个给定的内联函数或者constexpr函数来说，它的多个定义必须完全一致
inline bool eq(const BigInt&,const BigInt&){}
(b)放在头文件中，声明放在头文件中
void putValues(int* arr, int size);
练习6.44 将6.2.2节（第189页）的isShorter函数改写成内联函数
#include<string>
using namespace std;
inline bool isShorter(const string& s1, const string& s2) {
return s1.size() < s2.size();
}
int main()
{
string s1 = "aaaa";
string s2 = "bbb";
cout << isShorter(s1, s2) << endl;
}
练习6.45 回顾在前面的练习中你编写的那些函数，它们应该是内联函数吗？如果是，将它们改成内联函数；如果不是，请说明原因
练习6.46 能把isShorter函数定义成constexpr函数吗？如果能，将他改写成constexpr函数，如果不能，说明原因
不能，因为std::string::size()； 不是一个constexpr函数，s1.size() == s2.size()；不是一个常量表达式
6.5.3 调试帮助
练习6.47 改写6.3.2节（第205页）练习中使用递归输出vector内容的程序，使有条件地输出与执行过程有关的信息。例如，每次调用时输出vector对象的大小。分别在打开和关闭调试器的情况下编译并执行这个程序
#include<string>
#include<vector>
#include<assert.h>
using namespace std;
size_t a(vector<int> b, size_t i)
{
#ifndef NDEBUG
cerr << i << __func__ << " " << __FILE__ << " "
<< __LINE__ << " " << __TIME__ << " " << __DATE__ << endl;
#endif
if (i != 0) { //只要i不等于0就继续迭代，直到找到i=0，输出b【0】
--i;
i = a(b, i);
}
cout << b[i] << endl;
return ++i;
}
int main()
{
vector<int> b = { 0,1,2,3,4 };
size_t i = b.size();
a(b, i - 1); //因为b是从0开始计数，所以i要减1
}
练习6.48 说明下面这个循环的含义，它对assert的使用合理吗？
不合理，这里虽然没有语法错误，但是它的使用是不合理的。 assert 宏通常用于检查“不能发生”的条件。这里改成 assert(!cin)更加合理些。
#include<string>
#include<vector>
#include<assert.h>
using namespace std;
string s;
while(cin>>s&&s!=sought){}
assert(cin);
6.6 函数匹配
练习6.49 什么是候选函数？什么是可行函数？
候选函数：一是与被调用的函数同名，二是其声明在调用点可见；可行函数：一是其形参数量与本次调用提供的实参数量相等，二是每个实参的类型与对应的形参类型相同
练习6.50 已知有第217页对函数f的声明，对于下面的每一个调用列出可行函数。其中哪个函数是最佳匹配？如果调用不合法，是因为没有可匹配的函数还是因为调用具有二义性？
#include<string>
#include<vector>
using namespace std;
void f();
void f(int);
void f(int, int);
void f(double, double = 3.14);
int main()
{
f(2.56, 42); //错误，二义性
f(42); //与void f(int)匹配
f(42, 0); //与void f(int, int)匹配
f(2.56, 3.14); //与void f(double, double = 3.14)匹配
}
练习6.51 编写函数f的四个版本，令其各输出一条可以区分的消息。验证上一个练习的答案，如果你回答错了，反复研究本节的内容直到你弄清自己错在何处
#include<string>
#include<vector>
using namespace std;
void f() {
cout << "1" << endl;
}
void f(int) {
cout << "2" << endl;
}
void f(int, int)
{
cout << "3" << endl;
}
void f(double, double = 3.14)
{
cout << "4" << endl;
}
int main()
{
//f(2.56, 42); //错误，二义性
f(42); //与void f(int)匹配
f(42, 0); //与void f(int, int)匹配
f(2.56, 3.14); //与void f(double, double = 3.14)匹配
}
6.6.1 实参类型转换
练习6.52 已知有如下声明
void mainip(int, int)
{
}
double dobj;
//请指出下列调用中每个类型转换的等级（参见6.1.1节，第219页）
int main()
{
mainip('a'.'z'); //3等级，通过类型提升实现的匹配
mainip(55.4, dobj); //4等级，通过算数类型转换。
}
练习6.53 说明下列每周声明中的第二条语句会产生什么影响，并指出哪些不合法（如果有的话）
#include<string>
#include<vector>
using namespace std;
int calc(int&, int&);
int calc(const int&, const int&); //合法，实参可以为const int
int calc(char*, char*);
int calc(const char*, const char*);//合法，实参可以为const char*
int calc(char* const, char* const);//合法，顶层const，声明重复（可以重复声明，不可重复定义）
6.7 函数指针
练习6.54 编写函数的声明，令其接受两个int形参并且返回类型也是int；然后声明一个vector对象，令其元素是指向该函数的指针
参考链接：https://blog.csdn.net/shamozhizhoutx/article/details/82263038
//练习6.54 编写函数的声明，令其接受两个int形参并且返回类型也是int；然后声明一个vector对象，令其元素是指向该函数的指针
#include<string>
#include<vector>
using namespace std;
vector<int (*)(int, int)> vf;
//others:
int func(int a, int b);
using pFunc1 = decltype(func)*;
typedef decltype(func)* pFunc2;
using pFunc3 = int (*)(int a, int b);
using pFunc4 = int(int a, int b);
typedef int(*pFunc5)(int a, int b);
using pFunc6 = decltype(func);
vector<pFunc1> vec1;
vector<pFunc2> vec2;
vector<pFunc3> vec3;
vector<pFunc4*> vec4;
vector<pFunc5> vec5;
vector<pFunc6*> vec6;
int a(int, int);
using b = decltype(a);
vector<b*> vec;
练习6.55 编写4个函数，分别对两个int值执行加、减、乘、除运算；在上一题创建的vector对象中保存指向这些函数的指针
#include<string>
#include<vector>
using namespace std;
int add(int i, int j)
{
return i + j;
}
int sub(int i, int j)
{
return i - j;
}
int mul(int i, int j)
{
return i * j;
}
int except(int i, int j)
{
return i / j;
}
typedef decltype(add) name;
vector<name*> z = { add,sub,mul,except };
练习6.56 调用上述vector对象中的每个元素并输出其结果
#include<string>
#include<vector>
using namespace std;
int add(int i, int j)
{
return i + j;
}
int sub(int i, int j)
{
return i - j;
}
int mul(int i, int j)
{
return i * j;
}
int except(int i, int j)
{
return i / j;
}
typedef decltype(add) name;
int main()
{
vector<name*> z = { add,sub,mul,except };
for (auto& s : z) {
cout << s(4, 2) << endl;
}
}
549
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
