【C++】《C++ Primer》第六章：函数（知识点总结和习题答案）

已于 2022-11-05 16:39:29 修改
阅读量1.3k 收藏 1
点赞数
分类专栏： C++ 文章标签： c++
于 2022-11-01 15:32:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wind_2028/article/details/127634633
版权

目录

6.1 函数基础

静态局部对象 static类型

编程习惯！

6.2 参数传递

编程习惯！

const实参和形参

main函数的形参

数组作为参数

6.3 返回类型和return语句

错误的return

尾置返回类型

6.4 函数重载

重载和const形参

const_cast与重载

作用域对重载的影响

6.5 特殊用途

内联函数inline

6.7 函数指针

概念

写法和用法

函数自动转为函数指针

再看decltype

附：部分习题答案

6.1 函数基础

静态局部对象 static类型

用static声明后，变量的生命周期就是：从变量创建到程序结束。

注：static类型变量默认初始化为0

编程习惯！

关于函数的声明和定义：

小结：函数应该在头文件中声明，在源文件中定义。

附：声明和定义的区别

6.2 参数传递

编程习惯！

关于引用传递的参数类型：const型

const实参和形参

函数不会改变的形参如果不是const类型，则会有很多限制！

  • 被误认为这个参数是可以修改的！
  • 极大限制了函数所能接受的实参类型：
void test1(int& a) // 非const
{
	cout << a << endl;
}

void test2(const int& a) // 非const
{
	cout << a << endl;
}

void test()
{
	test1(10); // 错误！因为不能用字面值和非const引用绑定！
    test2(10); // 正确！因为test2的参数是const型

    const int a = 10;
    test1(a); // 错误！因为不能用const变量和非const引用绑定！
	test2(a); // 正确！因为都是const
    
}

因此，可以发现，如果函数的形参只是int&，那么只有int型的实参才能与之绑定；如果是const int&，那么字面值、int型、const int型都可以与之绑定。

main函数的形参

数组作为参数

两个特性：

  • 不允许拷贝数组 --> 无法值传递，只能引用传递
  • 使用数组的时候，会转为指针 --> 传一个数组，实际上传的是首元素指针

标准库规范：传递指向首元素和尾元素的指针

例子：

int &test1(int *a, int index) // 返回引用, 第一个参数是数组首元素的地址
{
	return a[index]; // 返回第index个元素的引用
}

void test()
{
	int a [] = {1,2,3,4,5};

	for (auto i : a)
	{
		cout << i << " ";
	}
	cout << endl;
    
	test1(a, 1) = 9; // 传入数组a,但会自动转为a[0]的地址; 因为左边是一个引用,因此可作为左值,因此可以直接赋值
	for (auto i : a)
	{
		cout << i << " ";
	}
}

6.3 返回类型和return语句

错误的return

尾置返回类型

记号：->

string a = "wind";

auto test(int *b) -> decltype(a) // auto的类型，就是根据decltype(a)的返回类型得到
{
	return a;
}

int main()
{
	int b[] = { 1,2,3,4 };
	auto c = test(b);
	cout << c;

	return 0;
}

下面三个函数等价：

// 结合decltype，依据模板参数推导返回类型 
template<typename ArgType1, typename ArgType2>
auto Func1(ArgType1& a, ArgType2& b) -> decltype(a + b) 
{ 
    return (a + b);
}

// 在C++14中可省略箭头返回值部分，直接将函数返回类型设置为auto 
template<typename ArgType1, typename ArgType2>
auto Func2(ArgType1& a, ArgType2& b)
{ 
    return (a + b);
}

// 也可以直接将返回类型定义为 decltype(auto) 
template<typename ArgType1, typename ArgType2>
decltype(auto) Func3(ArgType1& a, ArgType2& b)
{
    return (a + b);
}

6.4 函数重载

重载和const形参

只要记住：只有引用和指针作为形参，才可以重载！否则，都不行！

并且，会根据传入的顶层const类型去选择使用哪个重载函数:

// 正确
void test(int& i)
{
	cout << " 1 --- " << i << endl;
}

void test(const int& i)
{
	cout << " 2 --- " << i << endl;
}

// 错误
void test1(int i)
{
	cout << " 1 --- " << i << endl;
}

void test1(const int i)
{
	cout << " 2 --- " << i << endl;
}

int main()
{
	const int a = 10;
	test(a); // a是const，因此选择void test(const int& i), 输出 2 --- 10

	return 0;
}

const_cast与重载

const_cast常用在函数重载中！主要作用是：const型和非const型的相互转换。

使用的初衷：通常不希望修改传入的string，因此形参被返回类型都被定义为const，然而有时候需要返回一个非const的string，因此就需要用const_cast过渡一下。

string &test(const string &s1, const string &s2) // 错误，因为传入是const，返回必须是const
{
	return s1.size() > s2.size() ? s1 : s2;
}
正确：
const string &test(const string &s1, const string &s2)
{...}

int main()
{
	string s1 = "wind", s2 = "wind1";
	string &s = test1(s1, s2); // 错误，因为test返回的是const，因此必须是const型接收
    const string &s = test1(s1, s2); // 正确
	cout << s;
	return 0;
}

我们不希望修改s1和s2，因此test()要以const类型传入；然而我们希望第13行的s是可以修改的，但又必须用const string去接收，此时就不好办了。因此，要用const_cast过渡一下：

const string &test(const string &s1, const string &s2)
{
	return s1.size() > s2.size() ? s1 : s2;
}

string& test1(string& s1, string& s2)
{
	auto& r = test(const_cast<const string&>(s1), const_cast<const string&>(s2));
	return const_cast<string&>(r);
}

int main()
{
	string s1 = "wind", s2 = "wind1";

	string &s = test1(s1, s2);
	cout << s;
	return 0;
}

第8行，用先用const_cast<const string&>把非const的s1、s2转为const，调用test()，用一个const string &r去接收，然后再用const_cast<string&>把const的r转为非const的r。

作用域对重载的影响

一句话总结：如果在函数内层作用域中对函数做了重载，那么就会忽略所有函数外的函数重载。

只有把重载函数放在一个作用域中（例如都在函数外或函数内），才不会被忽略：

6.5 特殊用途

内联函数inline

主要作用：很多条件判断语句可以通过写一个小的函数去等价表示，这样更加清晰明了，也便于后期修改；然而函数调用是需要占用一定资源的（运行更慢），因此内联函数就用来解决这个问题。

关键字：inline

定义内联函数：

调用：

以上表面，对于较大的函数（比如有一百行），即使声明为inline，但编译器也可能不会当做内联函数使用，不然更费时间。

注：对于inline函数和constexpr函数，通常把声明和定义放在头文件中，因为这两个函数在程序中需要被多次定义，而这些定义必须一致！

6.7 函数指针

概念

顾名思义，就是指向函数的指针，这个指针可以代替函数来使用。

写法和用法

声明：

类型 (*指针名称)(形参);

例如：

const string& compare(const string& s1, const string& s2)
{
	return s1.size() > s2.size() ? s1 : s2;
}

void test()
{
	const string& (*p)(const string& s1, const string& s2);
	p = compare;

	cout << p << endl << &compare << endl; // 输出相同

	string b1 = p("wind", "wind1");
	cout << b1 << endl;
}

第1行，是一个函数；

第8-9行，就是定义一个函数指针p，指向第1行的函数；

注意：函数指针的返回类型、形参必须和函数定义保持一致

函数： const string& compare(const string& s1, const string& s2)

函数指针： const string& (*p)(const string& s1, const string& s2);

指针指向函数：p = compare;

第13行，使用函数指针p，代替直接调用函数compare()

注1：函数指针可以初始化为0或nullptr（因为本质上就是指针，遵循指针的初始化原则）

注2：重载函数指针时，必须清晰界定选用哪个函数，包括形参和返回类型：

函数自动转为函数指针

再看decltype

decltype只会返回类型，不会做任何数据转换！！因此很多时候需要手动转换！例如：

函数指针那里：

const string& compare(const string& s1, const string& s2)
{
	return s1.size() > s2.size() ? s1 : s2;
}

void test()
{
	const string& (*p)(const string& s1, const string& s2);
	p1 = compare;

	string b1 = p1("wind", "wind1");
	cout << b1 << endl;

	decltype(compare) *p2 = p1; // 重点在这里
	cout << &p2 << endl << &p1 << endl; // 地址不一样，不是同一个指针

	string b2 = p2("wind", "wind1");
	cout << b2 << endl;
}

第14行，decltype(compare)返回的是一个函数类型，因此需要加上*才能得到指针

附：部分习题答案

练习6-10

#include <iostream>
#define _CRT_SECURE_NO_DEPRECATE
using namespace std;
#include <string>
#include <vector>

void test1(int* a, int* b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}


void test()
{
	int a = 10, b = 20;
	test1(&a, &b);
	cout << a << endl << b << endl;


}


int main()
{
	test();

	return 0;
}

练习6-12

#include <iostream>
#define _CRT_SECURE_NO_DEPRECATE
using namespace std;
#include <string>
#include <vector>

void test1(int& a, int& b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}


void test()
{
	int a = 10, b = 20;
	test1(a, b);
	cout << a << endl << b << endl;


}


int main()
{
	test();

	return 0;
}

练习6-33

#include <iostream>
#define _CRT_SECURE_NO_DEPRECATE
using namespace std;
#include <string>
#include <vector>

// 我的答案 -- 写复杂了
vector<int>::iterator test1(vector<int>v, vector<int>::iterator begin, vector<int>::iterator end)
{
	if (begin + 1 == end)
	{
		cout << *begin << endl;
		return begin;
	}
	cout << *begin << endl;
	return test1(v, begin + 1, end);

}

// 参考答案
void print(vector<int>v, int index)
{
	int size = v.size();
	if (index != size)
	{
		cout << v[index++] << endl;
		print(v, index);
	}
}

void test()
{
	vector<int>v;
	for (int i = 0; i < 10; ++i)
	{
		v.push_back(i);
	}

	/// 调用我的答案
	//vector<int>::iterator begin = v.begin();
	//vector<int>::iterator end = v.end();
	//vector<int>::iterator iter = test1(v, begin, end);

	/// 调用参考答案
	int index = 0;
	print(v, index);

}

int main()
{
	test();

	return 0;
}

练习6-36

#include <iostream>
#define _CRT_SECURE_NO_DEPRECATE
using namespace std;
#include <string>
#include <vector>

// 6.36
string(&func())[10];

// 6.37
// 类型别名
typedef string arrT[10];
using arrT1 = string[10];
arrT& func();
arrT1& func();

// 尾置返回类型
auto func()->string(&)[10];

// decltype关键字
string str[10];
decltype(str)& func();


int main()
{
	return 0;
}

练习6-54

#include <iostream>
#define _CRT_SECURE_NO_DEPRECATE
using namespace std;
#include <string>
#include <vector>

void test()
{
	// 函数的声明
	int func(int, int);

	// vector对象的声明
	vector< decltype(func)* >v;

}

int main()
{
	return 0;
}

练习6-55和6-56

#include <iostream>
#define _CRT_SECURE_NO_DEPRECATE
using namespace std;
#include <string>
#include <vector>

int func1(int a, int b)
{
	return a + b;
}

int func2(int a, int b)
{
	return a - b;
}

void test()
{

	vector< decltype(func1)* >v;
	decltype(func1)* p1 = func1;
	decltype(func1)* p2 = func2;

	v = { p1, p2 };

	for (auto i : v)
	{
		cout << (*i)(1, 1) << endl;
	}

}

int main()
{
	test();

	return 0;
}

Dreamcatcher风
关注
专栏目录
C++Primer第五版——习题答案+详解(完整版)
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++primer第六章习题答案
qq_41714922的博客
07-06 579
#include<iostream> #include<vector> #include<string> #include<stdexcept> #include"6.h" using namespace::std; //6.3 //int fact(int val) { // if (val == 0 || val == 1) return 1; // else { // /*int a = 1; // for (i...
C++primer 第6章
qq_30035663的博客
07-18 495
看书总结
[C++ primer] 第六章习题答案
u013081759的博客
05-30 1118
[C++ primer] 第六章习题答案6.16.26.46.56.66.86.106.126.136.156.166.176.186.196.206.216.226.246.256.276.286.29 6.1 实参时形参的初始值。 形参是定义在函数参数列表中的局部变量， 等待被实参初始化。 实参是调用函数时给形参赋予的初始值。 6.2 （a）返回类型不匹配 （b）函数没有标明返回类型 （c）形...
C++ Primer(第五版) 第六章练习答案
LGDNSX
03-03 897
C++ Primer(第五版) 第六章练习答案 目录C++ Primer(第五版) 第六章练习答案6.16.26.36.46.56.66.76.86.9cc6.9h6.9cpp6.106.116.126.136.146.156.166.176.186.196.206.216.226.236.246.256.266.276.286.296.306.316.326.336.346.356.366.376.386.396.406.416.426.436.446.456.466.476.486.496.506.51
C++ Primer(第五版)第6章答案
阿飞的博客
09-08 810
C++ Primer(第五版)第6章答案
C++ Primer Plus 第6版 中文版课后代码习题答案
最新发布
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++Primer（第4版）-课后习题答案.pdf
11-01
《C++ Primer（第4版）》是一本深入学习C++编程语言的经典教材，其课后习题答案提供了丰富的实践练习和问题解析，帮助读者巩固并深化对C++语法、概念的理解。以下将针对各章节的主要知识点进行详细阐述： 1. 第一章...
c++primer第五版习题答案（第17章）
11-12
习题答案部分则是对这些练习题给出的解答，可以帮助学生和自学者检查和理解自己的解题过程是否正确，以及是否有更好的解决方式。由于这些答案是由个人通过OCR扫描获得的，并非官方提供，可能存在识别错误或漏识别的...
c++primer第五版习题答案（第12章）
11-12
此外，描述中提及的“真正的C++primer习题集”，这可能表明该习题集是针对教材内容设计的，目的是帮助学生消化和练习书中的理论知识。通过解决这些习题，学生可以加深对C++语言特性的理解，包括类和对象、动态内存...
C ++ Primer（第五版）第六章练习答案.zip
09-09
自己做的第六章的章节练习答案，一共19个编程cpp，其他问题是问答和函数编写我没有做成cpp文件，可以看文章有写-。-https://blog.csdn.net/weixin_43655901/article/details/108451342
C++ Primer 第六章答案
lovely_ke的博客
07-31 564
练习6.1 在函数调用，参数传递中，实参将内容复制给形参。 作用域：实参的作用域要大于形参，形参仅在被调用的函数中使用。 练习6.2 (a) int f() { // -> string f() string s; // ... return s; } (b) void f2(int i) { /* ... */ } ...
C++Primer第五版 第六章习题答案（41~50）
热门推荐
MISAYAONE的博客
02-15 1万+
41：知识点1：函数反复调用的过程中重复出现的形参，这样的值被称为默认实参。该参数在使用过程中可以被用户指定，也可以使用默认数值 知识点2：调用含有默认实参的函数时，可以包含该实参，也可以省略该实参。 知识点3：一旦某个形参被赋予了默认值，其后所有形参都必须有默认值。 知识点4：顺序很重要！在设计函数时，将默认值的形参放在后面。 知识点5：在给定的作用域中，一个形参只能被赋予一次默认实参，
C++Primer 第六版中文答案（第六章）
u010268103的专栏
06-27 794
6.11.1 # include # include
C++ primer(第五版）第6章习题答案
INFINITE POSSIBILITIES
03-08 467
第六章　函数 6.1 形参：在函数参数列表中声明的局部变量，它们由每个函数调用中提供的参数初始化。 实参：函数调用中提供的值，用于初始化函数的参数。 6.2 (a) 返回值类型应该是string (b) 返回值类型为void (c) 函数体缺少左花括号 (d) 函数体没有花括号 6.3 #include <iostream> int fact(...
C++Primer——第六章(函数)
杉杉coming！
07-22 341
6.1 函数基础 函数定义：包括返回类型、函数名字和0个或者多个形参组成的列表和函数体。 调用运算符：调用运算符的形式是一对圆括号()，作用于一个表达式，该表达式是函数或者指向函数的指针；圆括号内是用逗号隔开的实参列表。 函数的调用完成两项工作: 用实参初始化函数对应的形参 将控制权转移给被调用函数。（此时，主调函数的执行被暂时中断，被调函数开始执行） 注： 形参和实参：形参和实参的个数和类型必须匹配上。尽管实参与形参存在对应关系，但是并没有规定实参的求值顺序。 返回类型：void表示函数.
《C++ Primer》第五版课后习题解答_第六章（2）(08-15)
weixin_30564901的博客
09-14 97
系统环境： windows 10 1703 编译环境：Visual studio 2017 6.8 #pragma once #include <iostream> int adamfact(int val); int fact(int fac1); double Adamabs(double abs1); 6.9 Chapter6.h //见题目 6.8f...
C++ primer | 第6章 函数
bea_tree的博客
09-30 573
本章介绍函数如何定义和声明，包括如何传入函数及函数如何返回结果，以及一些包括函数指针的知识。6.1 函数基础一个典型的function 定义包括以下四个部分： - 返回类型 - 函数名字 - 形参（parameter）；调用时叫做argument，实参 - 函数体 通过调用运算符（call operator)来执行函数//阶乘 int fact(int val)// 如果函数不需要
C++ Primer 课后习题详解：第1-18章完整答案
- 第六章至第十三章分别涵盖表达式、语句、函数、IO库、容器、泛型算法、类和数据抽象以及复制控制，习题旨在巩固这些概念的实际应用。 - 第十四章和第十五章涉及操作符重载和面向对象编程，习题可能包括自定义操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值