第 6 章 函数

最新推荐文章于 2024-09-11 11:31:11 发布
最新推荐文章于 2024-09-11 11:31:11 发布
阅读量130 收藏
点赞数
分类专栏： C++ Primer 第5版 学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38359705/article/details/121166894
版权

练习6.1：

形参:在函数形参表中声明的局部变量。它们由每个函数调用中提供的参数初始化。
实数:函数调用中提供的值，用于初始化函数的形参。

练习6.2：

// (a)
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：

#include <iostream>
using namespace std;

int fact(int val)
{
    if (val == 0 || val == 1) 
        return 1;
    else return val * fact(val - 1);
}
// 注意int的范围
int main()
{
    cout << "Enter a number within [0, 13):" << endl;
    for (int i = 0; cin >> i; cout << "Enter a number within [0, 13):" << endl)
    {
        if (i < 0 || i >12)
            continue;
        cout << i << "! = " << fact(i) << endl;
    }
    return 0;
}

习题6.4：

#include <iostream>
using namespace std;

int fact(int val)
{
    if (val == 0 || val == 1) 
        return 1;
    else return val * fact(val - 1);
}

void factorial_with_interacts()
{
    cout << "Enter a number within [0, 13):" << endl;
    for (int i = 0; cin >> i; cout << "Enter a number within [0, 13):" << endl)
    {
        if (i < 0 || i >12)
            continue;
        cout << i << "! = " << fact(i) << endl;
    }
}

int main()
{
    factorial_with_interacts();
    return 0;
}

练习6.5：

template<typename T>
T abs(T val)
{
    return val >= 0 ? val : -val;
}

练习6.6：

形参:在函数形参表中声明的局部变量。

局部变量:在块中定义的变量。

局部静态变量:将局部变量定义成static类型令其生命周期贯穿函数调用及之后的时间。局部静态变量(对象)在第一次执行经过对象定义语句时被初始化，并且直到程序终止时才被销毁。

练习6.7：

size_t func()
{
    static size_t ctr = 0;
    return ctr++;
}

练习6.8：

int fact(int val);
void factorial_with_interacts()；
size_t func();

template<typename T>
T abs(T val)
{
    return val >= 0 ? val : -val;
}

练习6.10：

#include<iostream>
using namespace std;

void swap(int *const lhs, int *const rhs)
{
    int temp = *lhs;
    *lhs = *rhs;
    *rhs = temp;
}

int main()
{
    cout << "enter two integer:" << endl;
    for (int lhs, rhs; cin >> lhs >> rhs; cout << "enter two integer:" << endl)
    {
        swap(&lhs, &rhs);
        cout << lhs << " " << rhs << endl;

    }
    return 0;
}

练习6.11：

#include<iostream>
using namespace std;

void set(int &i)
{
    i = 0;
}

int main()
{
    int i = 1;
    set(i);
    cout << i << endl;
    return 0;
}

练习6.12：

#include<iostream>
using namespace std;

void swap(int &lhs, int &rhs)
{
    int temp = lhs;
    lhs = rhs;
    rhs = temp;
}

int main()
{
    cout << "enter two integer:" << endl;
    for (int lhs, rhs; cin >> lhs >> rhs; cout << "enter two integer:" << endl)
    {
        swap(lhs, rhs);
        cout << lhs << " " << rhs << endl;

    }
    return 0;
}

练习6.13：

void f(T)通过值传递参数。函数对形参的任何操作都不会影响实参。
void f(T&)通过引用传递参数，允许函数改变实参的值。

练习6.14：

// 形参是引用
void reset(int &i)
{
        i = 0;
}
// 形参不能是引用
void print(vector<int>::iterator begin, vector<int>::iterator end)
{
    for (std::vector<int>::iterator iter = begin; iter != end; ++iter)
        cout << *iter << endl;
}

练习6.15：

为什么s是常量引用而occurs是普通引用?

        s不应该被这个函数改变，所以是常量引用。但occurs的结果必须由函数来计算，所以是普通引用。

为什么s和occurs是引用类型而c不是?

        c在这里可以使用const引用，但直接复制char会更节省内存。

如果令s是普通引用会发生什么?如果令occurs是常量引用呢?

        s可以在函数中改变，occurs不会改变，所以occurs = 0是一个错误。

练习6.16：

bool is_empty(const string& s) { return s.empty(); }

        因为这个函数不改变实参，所以应该加上"const"在string&s之前，否则该函数会产生误导，不能使用const string或const函数。

练习6.17：

#include<iostream>
#include<string>
using namespace std;

// 判断是否有大写字母
bool is_capital(const string &s)
{
	for (auto c : s)
	{
		if (!isupper(c))
			return true;
	}
	return false;
}
// 将大写字母转换为小写字母
const string &to_lower(string &s)
{
	for (auto &c : s) // 必须引用 s才会修改
	{
		if (isupper(c))
			c = tolower(c);
	}
	return s;
}

int main()
{
	cout << "enter a string:" << endl;
	for (string str; getline(cin, str); cout << "enter a string:" << endl)
	{
		cout << str << " has capital letter ? " 
            << (is_capital(str) ? "true" : "false") << endl;
		cout << "Convert all to lowercase letters:\n " << to_lower(str) << endl;
	}
	return 0;
}

练习6.18：

// (a)
bool compare(const matrix&, const matrix&);
// (b)
vector<int>::iterator change_val(int, vector<int>::iterator);

练习6.19：

(a) 非法，函数只有一个形参。 (b) 合法 (c) 合法 (d) 合法

练习6.20：

        如果函数无需改变引用形参的值，最好将其声明为常量引用。把函数不会改变的形参定义成普通引用是一种比较常见的错误，这么做带给函数的调用者一种误导，即函数可以修改它的实参的值。使用引用而非常量引用也会极大地限制函数所能接受的实参类型。例如，不能把const对象、字面值常量或者需要类型转换的对象传递给普通的引用形参。

练习6.21：

#include<iostream>
using namespace std;

int LargeOne(int ival, const int* const iptr)
{
	return ival > *iptr ? ival : *iptr;
}

int main()
{
	int i = 0;
	cout << LargeOne(1, &i) << endl;
	return 0;
}

练习6.22：

#include<iostream>
using namespace std;

void swap_ptr(const int*& ip1, const int*& ip2)	// 必须引用，否则无法交换指针的值
{
	auto temp = ip1;
	ip1 = ip2;
	ip2 = temp;
}

int main()
{
	const int i = 42, j = 99;
	auto ip1 = &i;
	auto ip2 = &j;
    // 指针的值和指针所指的值都改变了
	cout << *ip1 << " " << *ip2 << endl;
	cout << ip1 << " " << ip2 << endl;
	swap_ptr(ip1, rhs);
	cout << *ip1 << " " << *ip2 << endl;
	cout << ip1 << " " << ip2 << endl;

	return 0;
}

练习6.23：

#include<iostream>
using namespace std;

void print(const int* ip)
{
	if (ip)
		cout << *ip << endl;
}

void print(const char* cp)
{
	if (cp)
	{
		while (*cp)
			cout << *cp++;
	}
	cout << endl;
}

void print(const int* beg, const int* end)
{
	while (beg != end)
		cout << *beg++ << " ";
	cout << endl;
}

// const int ia[]等价于const int* ia
void print(const int ia[], size_t size)
{
	for (size_t i = 0; i != size; ++i)
		cout << ia[i] << " ";
	cout << endl;
}

void print(const int(&arr)[2])
{
	for (auto elem : arr)
		cout << elem << " ";
	cout << endl;
}

int main()
{
	int i = 0, j[2] = { 0,1 };
	char ch[5] = "pezy";
	print(&i);
	print(ch);
	print(begin(j), end(j));
	print(j, end(j) - begin(j));
	print(j);

	return 0;
}

练习6.24：

// 形参传递指针
void print(const int ia[10])
{
	for (size_t i = 0; i != 10; ++i)
		cout << ia[i] << " ";
	cout << endl;
}
// 代码能正确输出，等价于
void print(const int* ia)
{
	for (size_t i = 0; i != 10; ++i)
		cout << *(ia + i) << " ";
	cout << endl;
}
// 改为形参传递数组
void print(const int (&ia)[10])
{
	for (auto i : ia)
		cout << i << " ";
	cout << endl;
}

练习6.25 && 练习6.26：

#include<iostream>
#include<string>
using namespace std;

int main(int argc, char** argv)
{
    string str;
    // argv[0]保存程序的名字，而非用户输入
    for (int i = 1; i != argc; ++i) 
    {
        str += argv[i];
        str += " ";
    }

    cout << str << endl;
}

练习6.27：

#include<iostream>
#include<initializer_list>
using namespace std;

int sum(const initializer_list<int>& il)
{
    int sum = 0;
    for (auto i : il) 
        sum += i;
    return sum;
}

int main()
{
    cout << sum({1, 2, 3, 4, 5}) << endl;
    return 0;
}

练习6.28：

const string&

练习6.29：

        取决于initializer_list元素的类型。当类型为PODType时，不需要引用。因为POD的复制成本很低（比如int）。否则，使用引用（const）是更好的选择。

练习6.30：

错误#1    “str_subrange”: 函数必须返回值

错误#2：控制流可能尚未返回任何值就结束了函数的执行，编译器可能检查不出这一错误。

练习6.31：

        函数返回局部对象的引用时无效；当我们希望函数返回的对象可以被修改时，返回常量的引用无效。

练习6.32：

        合法，给数组赋值。

练习6.33：

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

template<typename T>
void printVec(T beg, T end)
{
    if (beg != end)
    {
        cout << *beg << " ";
        printVec(next(beg), end);
    }
}

int main()
{
    vector<string> vec{ "hello", "cap" };
    printVec(vec.begin(), vec.end());

    return 0；
}

练习6.34：

        如果参数为正数，递归停止到零；如果参数为负数，递归永远不会停止。

练习6.35：

        因为递归函数将始终使用val作为参数，会发生递归循环。

练习6.36：

string(&func(string (&arry)[10]))[10];

练习6.37：

// 使用类型别名
typedef string ArrT[10];     // using ArrT = string[10]
ArrT& func1(ArrT& arr);
// 使用尾置返回类型
auto func2(ArrT& arr)->string(&)[10];
// 使用decltype
string Arr[10];
decltype(Arr)& func3(decltype(Arr)& arr);

练习6.38：

int odd[] = { 1,3,5,7,9 };
int even[] = { 0,2,4,6,8 };
decltype(odd)& arrptr(int i)
{
    return (i % 2) ? odd : even;
}

练习6.39：

(a) 重复声明，顶层const不影响传入函数的参数。

(b) 错误声明，不允许两个函数除了返回类型外其他所有的要素都相同。

(c) 合法。

练习6.40：

(a) 正确

(b) 错误，一旦某个形参被赋予了默认值，它后面的所有形参必须有默认值。

练习6.41：

(a) 非法，不匹配ht

(b) 合法，调用init(24,10,' ')。

(c) 合法，调用init(24, ' * ', ' ')，char类型的实参隐式地转换成int，但不符初衷。

练习6.42：

#include<iostream>
#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 << "singual: " << make_plural(1, "success", "es") << " "
        << make_plural(1, "failure") << endl;
    cout << "plural : " << make_plural(2, "success", "es") << " "
        << make_plural(2, "failure") << endl;

    return 1;
}

练习6.43：

        两个都应该放在头文件中。(a)是内联函数。(b)是函数的声明。

练习6.44：

inline bool isShorter(const string& s1, const string& s2)
{
    return s1.size() < s2.size();
}

练习6.45：

        内联机制用于优化规模小，流程直接，频繁调用的函数。

练习6.46：

        constexpr函数的返回类型及所有形参的类型都得是字面值类型，而且函数体中必须有且只有一条return语句。string 类型不是字面值类型。

练习6.47：

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

//#define NDEBUG

template<typename T>
void printVec(T vec)
{
#ifndef NDEBUG
    cout << "vector size: " << vec.size() << endl;
#endif
    if (!vec.empty())
    {
        auto tmp = vec.back();
        vec.pop_back();
        printVec(vec);
        cout << tmp << " ";
    }
}

int main()
{
    vector<string> vec{ "Hello", "Cpp" , "Java"};
    printVec(vec);
    cout << endl;

    return 0;
}

练习6.48：

这个循环允许用户一直输入一个单词直到找到该单词为止。

这不是assert的一个好用法，assert宏常用于检查“不能发生”的条件。但是assert总是在用户输入eof时发生，这种行为很自然，检查毫无必要。使用 assert (!cin || s == sought)会更好。

练习6.49：

        函数匹配中第一步中，选定调用对应的重载函数集，集合中的函数为候选函数。候选函数具备两个特征：一是与被调用的函数同名，二是其声明在调用点可见。

        第二步考察本次调用提供的实参，然后从候选函数中选出能被这组实参调用的函数，称为可行函数。候选函数也有两个特征：一是其形参数量与本次调用提供的实参数量相等，二是每个实参的类型与对应的形参类型相同，或者可以转换成形参的格式。

练习6.50：

(a) 不合法，调用具有二义性。

(b) 匹配        void f(int)

(c) 匹配        void f(int, int)

(d) 匹配        void f(double, double = 3.14)

练习6.51：

#include<iostream>
using namespace std;

void f() { cout << "f()" << endl; }
void f(int i) { cout << "f(int)" << endl; }
void f(int i1, int i2) { cout << "f(int, int)" << endl; }
void f(double d1, double d2 = 3.14) { cout << "f(double, double = 3.14)" << endl; }

int main()
{
    //f(2.56, 42);
    f(42);
    f(42, 0);
    f(2.56, 3.14);

    return 0;
}

练习6.52：

(a) 通过类型提升实现的匹配

(b) 通过算数类型转换实现的匹配

练习6.53：

(a) 第一句只能调用非常量对象，第二句都可以.

(b) 第一句的实参是指向非常量的指针,第二句都可以。

(c) 不合法。顶层const，都是调用指向字符类型的指针

练习6.54：

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;

练习6.55 && 练习6.56：

#include<iostream>
#include<vector>
using namespace std;

int func(int a, int b);
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return b != 0 ? a / b : 0; }

int main()
{
    vector<decltype(func)*> vec{ add, subtract, multiply, divide };
    for (auto f : vec)
        cout << f(2, 2) << endl;    // (*f)(2, 2)
    return 0;
}

++Z++
关注
专栏目录
第6章 函数.pptx
05-21
### 第6章 函数 #### 一、什么是函数？ 在编程中，函数是一段被封装起来的代码，它可以实现特定的功能并且可以被多次调用。使用函数的主要目的是提高代码的复用性和模块性，使程序结构更加清晰。例如，在一个程序...
C++构造函数
ThorKing01的博客
08-12 1555
构造函数没有返回类型 默认构造函数 ：参数列表为空 合成的默认构造函数：一些简单的类中没有显示地定义默认构造函数，编译器会为其隐式地生成默认构造函数，这个默认构造函数称为合成的默认构造函数。 但是有些类不能依赖于合成的默认构造函数，必须自定义默认构造函数。原因有三： 1.定义了其它的构造函数。 2.合成的默认构造函数可能会执行错误的初始化操作。例如，当对象中含有数组或指针类型的时候，被合成的...
C++ //练习 6.42 给make_plural函数（参见6.3.2节，第201页）的第二个形参赋予默认实参‘s‘，利用新版本的函数输出单词success和failure的单数和复数形式。
Made in Code
02-14 216
【代码】C++ //练习 6.42 给make_plural函数（参见6.3.2节，第201页）的第二个形参赋予默认实参's'，利用新版本的函数输出单词success和failure的单数和复数形式。
c++primer练习6.42、6.43、6.44、6.46、6.47、6.48
一个搬运知识的笨小孩
04-07 454
练习6.42 给make_plural(复数)函数的第二个形参赋予默认实参 ‘s’，利用新版本的函数输出单词success和failure的单数和复数形式 #include <iostream> //使用命名空间std using namespace std; //形参：字符串长度，字符串内容，要在字符串添加的字符(默认添加s) string make_plural(size_t ctr, const string &word, const string &ending="s")
C++ 随记三 （一些杂项）
m0_51551385的博客
03-16 1267
1、使用只读算法时，传参要注意： 比如，accumulate就是个只读函数： string sum = accumulate(s.cbegin(), s.end(), string("")); 插一嘴，最后一个参数必须是string("")，不能只写一个空字符串""上去，因为第三个参数的类型决定accumulate函数调用哪种类型的+运算符，而const char*没有+运算符，会产生编译错误。 2、使用equal的注意事项 equal不能比较两个【C风格的字符串】是否相等。 因为C风格的字符串本质是c
第6章 函数
02-24
本章主要介绍了函数的各个方面，包括概述、定义、返回值、调用、变量作用域和存储类别。 首先，函数大致分为四类：库函数（如printf()、scanf()等）、主函数（main()）、用户自定义函数以及空函数。用户自定义函数...
第6章 函数.ppt
11-16
本章主要围绕C语言中的函数展开，涵盖了函数的定义、调用、返回值以及库函数的使用。 首先，C语言提供了大量的库函数，包括数学运算、类型转换、字符串处理、I/O操作、文件管理和字符处理等功能。在使用这些库函数...
第6章 函数-4代码风格1
08-03
【描述】：“第6章 函数——代码风格C语言程序设计第6章 函数基本的代码规范Basic rules and guidelines of Coding Style程序版式程序注释命名规则追求清晰、整洁、美观、一目了然容易阅读，容易测试” 在C语言程序...
make_plural
Make Progress Everyday!
11-30 2637
string make_plural (size_t ctr , const string &word , const string &ending) { return ( ctr == 1 ) ? word : word + ending; } size_t是一种整型的变量，宽度应该是比int大的，整个函数的意思就是。你传递进来的ctr是1吗？如果是就返回word字符串，如果不是就将两个字符
C++Primer第五版 习题答案 第六章 函数（Functions）
shamozhizhoutx的博客
08-31 9274
编写一个函数，令其接受两个参数：一个是int型的数，另一个是int指针。函数比较int的值和指针所指的值，返回较大的那个。可行函数是从候选函数中选出的，有两个特征：一是其形参数量与本次调用提供的实参数量相等，二是每个实参的类型与对应的形参类型相同，或者能转换成形参的类型。为上一题的函数再写三个声明，一个使用类型别名，另一个使用尾置返回类型，最后一个使用decltype关键字。假设 T 是某种类型的名字，说明以下两个函数声明的区别：一个是void f(T), 另一个是 void f(&T)。
《C++ Primer》习题参考答案：第6章 - C++模块设计——函数
种树最好的时间是10年前，其次是现在！！！
01-14 5075
第六章 函数 练习6.1 实参和形参的区别的什么？ 解： 实参是函数调用的实际值，是形参的初始值。 练习6.2 请指出下列函数哪个有错误，为什么？应该如何修改这些错误呢？ (a) int f() { string s; // ... return s; } (b) f2(int i) { /* ... */ } (c) int calc(...
C++Primer第六章(习题解答）：函数
qq_50271250的博客
09-05 1058
函数基础 6.1节练习 6.1 实参与形参的区别 答：形参出现在函数定义的地方，实参出现在函数调用的地方，实参的类型和个数与形参对应。 6.2 请指出下列函数的错误？ (a)int f(){ string s; //... return s; } 答：返回值不匹配，应该string f() (b)f2(int i){} 答：没有显示返回值的类型，可以为int f(int i){} (c)int calc(int v1,int v1){} 答：参数不能相同 (d)double square(doubl
const的用法
a2269816的专栏
05-30 400
首先说明一下使用const的好处： 使用const的好处在于它允许指定一种语意上的约束------某种对象不能被修改--------编译器具体来实施这种约束。通过const，你可以通知编译器和其他程序员某个值要保持不变。只要是这种情况，你就要明确地使用const ，因为这样做就可以借助编译器的帮助确保这种约束不被破坏。 （一） 首先解释一下const与指针的关系： const在指针的声明中
C语言回调函数注册和调用
最新发布
g200407331的专栏
09-11 303
/ 清除掉 TIMx 的更新中断标志。printf("TIM3 中断\r\n");// 判断 TINM3 中的中断更新事件是否被触发。分类专栏： CH32V203 文章标签： risc-v。// 加作者VX: jiyuyun18, 交流电子技术。于 2024-05-09 10:34:45 发布。// TIM3 回调函数指针。// 定时器中断服务函数。// TIM3 回调函数。// 定义回调函数类型。
【c++23种设计模式概述】
m0_45463480的博客
09-09 731
c++23种设计模式概述。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 211
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 762
C语言 | Leetcode C语言题解之第389题找不同
"C语言程序设计第二版第6章函数概述与封装功能模块
在C语言程序设计的第二版第6章1.ppt中，详细介绍了函数概述的相关内容。函数是一个有特定功能的独立单元，可以在程序中多次调用和执行。函数能够将复杂的问题分解为更小的任务，使程序结构清晰，易于理解和维护。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值