《C++PrimerPlus》第8章 函数探幽

已于 2023-11-29 14:10:11 修改
阅读量112 收藏
点赞数
分类专栏： 《C++PrimePlus》学习记录 文章标签： c++
于 2023-11-20 20:23:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mako5455/article/details/134418073
版权

8.1 内联函数

使用内联函数

#include <iostream>
using namespace std;

inline double square(double x) { return x * x; }

int main(){
	double a;
	a = square(5.0);
	cout << "a = " << a << endl;
	return 0;
}

8.2 引用变量

将引用用作函数参数（使用const）

#include <iostream>
using namespace std;
double cube(const double &ra);

int main(){
	double x = 3.0;
	cout << cube(x) << " = cube of " << x << endl;
	cout << cube(5) << " = cube of " << "5" << endl;
	cout << cube(x+5) << " = cube of " << x+5 << endl;
	return 0;
}

double cube(const double &ra) {
	return ra*ra*ra;
}

将引用用于结构

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

struct free_throws {
	string name;
	int made;
	int attempts;
	float percent;
};

void set_pc(free_throws &ft);
void display(const free_throws &ft);
free_throws &accumulate(free_throws &target, const free_throws &source);

int main(){
	free_throws one = { "Rick", 13, 14 }; // 最后一个值没赋值，为空
	free_throws two = { "Jack", 10, 16 };
	free_throws team = { "All", 0, 0 };
	set_pc(one); // 赋值
	display(one); // 展示
	display(accumulate(team, one)); // 汇总
	return 0;
}

void set_pc(free_throws &ft) { // 要修改原始数据，不加const
	if (ft.attempts != 0)
		ft.percent = 100.0 * float(ft.made) / float(ft.attempts);
	else
		ft.attempts = 0;
}

void display(const free_throws &ft) {
	cout << "Name: " << ft.name << endl;
	cout << "Made: " << ft.made << '\t';
	cout << "Attempts: " << ft.attempts << '\t';
	cout << "Percent: " << ft.percent << endl;
}
// 把函数的返回值定义为结构体引用
free_throws &accumulate(free_throws &target, const free_throws &source) {
	target.attempts += source.attempts;
	target.made += source.made;
	set_pc(target);
	return target;
}

将引用用于类的对象

#include <iostream>
#include <string>
using namespace std;
string version1(const string &s1, const string &s2);
const string &version2(string &s1, const string &s2);
// const string &version3(string &s1, const string &s2);

int main(){
	string input;
	string copy;
	string result;
	cout << "Enter a string: ";
	getline(cin, input);
	copy = input;
	cout << "You string: " << input << endl;
	result = version1(input, "***"); // 在字符串前后都加上***
	cout << "Your string enhanced: " << result << endl;
	cout << "Your input: " << input << endl;
	cout << "-------------------------------------" << endl;
	result = version2(input, "###");
	cout << "Your string enhanced: " << result << endl;
	cout << "Your input: " << input << endl;
	//cout << "-------------------------------------" << endl;
	//input = copy;
	//result = version3(input, "@@@");
	//cout << "Your string enhanced: " << result << endl;
	//cout << "Your input: " << input << endl;
	return 0;
}
// const string &s2 对应的是 "***"
// 当使用const限定符时，会产生临时变量并进行类型转换
string version1(const string &s1, const string &s2) {
	string temp;
	temp = s2 + s1 + s2;
	return temp;
}
// 返回一个string类的对象的引用
const string &version2(string &s1, const string &s2) {
	s1 = s2 + s1 + s2;
	return s1;
}

/*错误的使用方法：返回临时变量的引用
const string &version3(string &s1, const string &s2) {
	string temp;
	temp = s2 + s1 + s2;
	return temp;
}
*/

对象、继承和引用

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
using namespace std;
const int LIMIT = 5;
void file_it(ostream &os, double fo, const double fe[], int n);

int main(){
	fstream fout;
	// 先在路径中里新建这个txt文件
	const char *fn = "ep-data.txt";
	fout.open(fn);
	if (!fout.is_open()) {
		cout << "Can't open " << fn << "." << endl;
		exit(EXIT_FAILURE);
	}

	double objective; // 物镜的焦距
	cout << "Enter the focal length of telescope objective in mm: ";
	cin >> objective;
	double eps[LIMIT]; // 目镜的焦距
	for (int i = 0; i < LIMIT; i++) {
		cout << "Eyepieces #" << i + 1 << ": ";
		cin >> eps[i];
	}

	file_it(cout, objective, eps, LIMIT); // 在终端上显示
	file_it(fout, objective, eps, LIMIT); // 在文件中显示
	cout << "Done." << endl;
	return 0;
}
// ostream &os 基类的引用，可以指向基类的对象，也可以指向派生类的对象
void file_it(ostream &os, double fo, const double fe[], int n) {
	os << "Focal length of objective: " << fo << endl;
	os << "f.l. eyepieces" << " magnification" << endl;
	for (int i = 0; i < n; i++) {
		os << "    " << fe[i] << "    " << int(fo / fe[i] + 0.5) << endl;
	}
}

8.3 默认参数

默认参数的用法（取出字符串的前n个值）

#include <iostream>
using namespace std;
const int ArSize = 80;
char *left(const char *str, int n = 1); // 默认参数n=1

int main(){
	char sample[ArSize];
	cout << "Enter a string: " << endl;
	cin.get(sample, ArSize);

	char *ps = left(sample, 4);
	cout << ps << endl;
	delete[] ps; // 注意new和delete成对出现
	ps = left(sample); // 使用默认参数
	cout << ps << endl;
	delete[] ps;

	return 0;
}

char *left(const char *str, int n) {
	int m = 0;
	while (m < n && str[m] != '\0') m++; // 确定字符串长度
	char *p = new char[m + 1];
	int i;
	for (i = 0; i < m; i++) {
		p[i] = str[i];
	}
	p[i] = '\0'; // 最后要补上一个空字符
	return p;
}

8.4 函数重载

函数重载示例（取出字符串/数字的前n个值）

#include <iostream>
using namespace std;
const int ArSize = 80;
char *left(const char *str, int n = 1);
unsigned long left(unsigned long num, unsigned int ct);

int main(){
	const char *trip = "Hawaii";
	unsigned long n = 12345678;
	int i;
	char *temp;
	for (i = 0; i < 10; i++) {
		cout << left(n, i) << endl;
		temp = left(trip, i);
		cout << temp << endl;
		delete[] temp;
	}
	return 0;
}

char *left(const char *str, int n) {
	int m = 0;
	while (m < n && str[m] != '\0') m++; // 确定字符串长度
	char *p = new char[m + 1];
	int i;
	for (i = 0; i < m; i++) {
		p[i] = str[i];
	}
	p[i] = '\0'; // 最后要补上一个空字符
	return p;
}

unsigned long left(unsigned long num, unsigned int ct) {
	unsigned long n = num;
	unsigned int digits = 1;
	if (num == 0 || ct == 0) return 0; // 特殊情况
	while (n /= 10) digits++; // 判断数字有几位
	if (digits > ct) {
		ct = digits - ct; // 要除几次10
		while (ct--) num /= 10;
		return num;
	}
	else
		return num;
}

8.5 函数模板

函数模板示例（交换两个数的值）

#include <iostream>
using namespace std;
template <typename T>
void Swap(T &a, T &b);

int main(){
	int i = 10;
	int j = 20;

	cout << "i, j = " << i << ", " << j << "." << endl;
	Swap(i, j);
	cout << "Afer swap, i, j = " << i << ", " << j << "." << endl;
	
	double x = 24.5;
	double y = 81.7;
	cout << "x, y = " << x << ", " << y << "." << endl;
	Swap(x, y);
	cout << "Afer swap, x, y = " << x << ", " << y << "." << endl;

	return 0;
}

template <typename T>
void Swap(T &a, T &b) {
	T temp;
	temp = a;
	a = b;
	b = temp;
}

重载的模板示例（交换两个数或两个数组）

#include <iostream>
using namespace std;
template <typename T>
void Swap(T &a, T &b);
template <typename T>
void Swap(T a[], T b[], int n);
const int LIMIT = 8;
void show(int arr[], int n);


int main(){
	int i = 10;
	int j = 20;
	cout << "i, j = " << i << ", " << j << "." << endl;
	Swap(i, j);
	cout << "Afer swap, i, j = " << i << ", " << j << "." << endl;
	
	int d1[LIMIT] = { 0,7,0,4,1,7,7,6 };
	int d2[LIMIT] = { 0,7,2,0,1,9,6,9 };
	cout << "Original arrays: " << endl;
	show(d1, LIMIT);
	show(d2, LIMIT);
	Swap(d1, d2, LIMIT);
	cout << "After swap: " << endl;
	show(d1, LIMIT);
	show(d2, LIMIT);

	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 arr[], int n) {
	for (int i = 0; i < n; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;
}

调用函数时的最佳匹配（打印数组内容）

#include <iostream>
using namespace std;
template <typename T>
void ShowArray(T arr[], int n);
template <typename T>
void ShowArray(T *arr[], int n);

struct debts {
	char name[50]; // 名字
	double amount; // 数量
};

int main(){
	int things[6] = { 13,31,103,301,310,130 };
	struct debts mr_E[3] = 
	{
		{"Rick", 2400.00},
		{"Jack", 1300.0},
		{"Rose", 1800.0}
	};
	double *pd[3]; // 3个元素的数组，每个元素都是指针
	for (int i = 0; i < 3; i++) {
		pd[i] = &mr_E[i].amount;
	}
	ShowArray(things, 6);
	// 更匹配 void ShowArray(T *arr[], int n)
	// 会打印出来指针指向的数值
	ShowArray(pd, 3); 
	return 0;
}

template <typename T>
void ShowArray(T arr[], int n) {
	cout << "template A:" << endl;
	for (int i = 0; i < n; i++)
		cout << arr[i] << " ";
	cout << endl;
}

template <typename T>
void ShowArray(T *arr[], int n) {
	cout << "template B:" << endl;
	for (int i = 0; i < n; i++) 
		cout << *arr[i] << " ";
	cout << endl;
}

引导编译器使用指定函数（打印较小的值）

#include <iostream>
using namespace std;
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(){
	int m = 20, n = -30;
	double x = 15.5, y = -25.9;
	// 非模板函数优先，调用的是函数2
	cout << lesser(m, n) << endl;
	// 非模板函数不是最优（要进行类型转换），调用的是函数1
	cout << lesser(x, y) << endl;
	// 尖括号<>告诉编译器使用模板函数，调用函数1
	cout << lesser<>(m, n) << endl;
	// 把x和y强制转换为int类型，再使用模板函数2
	cout << lesser<int>(x, y) << endl;
	return 0;
}

Mako5455
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C++ Prime Plus 第八章》——内联函数
fk961859482的专栏
12-14 857
内联函数是C++为提高程序运行速度所做的一项改进。常规函数和内联函数之间的主要区别不在于编写方式，而在于C++编译器如何将它们组合到程序中。要了解内联函数与常规函数之间的区别，必须深入到程序内部。          编译过程的最终产物是可执行的程序——由一组机器语言指令组成。运行程序时，操作系统将这些指令载入到计算机内存中，因此每条指令都有特定的内存地址。计算机随后将逐步执行这些指令。有时(如有
【重学《C++Primer第四版》】第七章、函数
职场亮哥
04-13 474
Details of knowledge 1.如果使用引用形参的唯一目的是避免复制形参，则应将形参定义为const应用。 bool isShortrer(const string &s1,const string &s2) { return s1.size()<s2.size(); }2.千万不能返回局部变量的引用，也不要返回指向局部变量的指针。 当函数执行完毕时，字符串r
C++ PrimerPlus第8章 函数探幽
奇树谦的博客
01-27 259
C++ PrimerPlus第8章 函数探幽 8.1 C++内联函数 为了提高程序运行速度。和常规函数的主要区别在于C++编译器如何将它们组合到程序中。 编译器将使用相应的函数代码替换函数调用。对于内联代码，程序无需跳到另一个位置处执行代码，再跳回来。因此，内联函数的运行速度比常规函数稍快，但代价是需要占用更多内存。 应当选择地使用内联函数。如果代码执行时间比处理函数调用机制的时间长，则节省的时间将只占整个过程的很小一部分。如果代码执行时间很短，则内联调用就可以节省非内联调用使用的大部分时间。另一方面，由于
C++PrimerPlus 第八章 函数探幽-8.5 函数模板
Hank_W
12-19 499
现在的C++编译器实现了C++新增的一项特性——函数模板。函数模板是通用的函数描述，也就是说，它们使用泛型来定义函数，其中的泛型可用具体的类型（如int或double）替换。通过将类型作为参数传递给模板，可使编译器生成该类型的函数。由于模板允许以泛型（而不是具体类型）的方式编写程序，因此有时也被称为通用编程。由于类型是用参数表示的，因此模板特性有时也被称为参数化类型（parameterized types）。下面介绍为何需要这种特性以及其工作原理。
C++ Primer Plus 第八章 函数探幽
weixin_43753276的博客
11-04 177
C++ primer plus 学习记录
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
在《C++ Primer Plus 第6版》中，读者会学习到变量、数据类型、运算符、流程控制、函数等基本元素。 2. **类与对象**：C++的核心在于类的定义和对象的创建。类是一种数据结构，用于封装数据和操作数据的方法。对象...
C++Primer Plus附录源码等文件.zip
12-27
《C++ Primer Plus》是Stephen Prata撰写的一本广受欢迎的C++编程教材，第六版提供了深入浅出的C++语言教程，旨在帮助初学者和有一定经验的程序员掌握这一强大的编程语言。附录中的源码文件是作者为配合书中的教学...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
C++ Primer Plus 编程练习源码工程 第8章
08-02
《C++ Primer Plus 编程练习源码工程 第8章》是针对C++初学者的一份宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这本书是C++编程领域的重要参考资料，而第8章的...
C++初探究（2）
Frenemy__的博客
07-09 1487
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1018
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
05day--C++日期类的实现与取地址运算符的重载
最新发布
weixin_73863912的博客
07-13 355
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C语言操作符详解
z317920的博客
07-11 610
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 1003
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
深入解析【C++ list 容器】：高效数据管理的秘密武器
小李很执着的博客
07-09 960
C++ 中的 list 容器是一个基于双向链表的序列式容器，适用于需要频繁插入和删除操作的场景，但不支持随机访问。list 提供了多种构造方法和丰富的操作接口，包括插入、删除、访问等。与 vector 相比，list 在插入和删除操作上更高效，但在随机访问和空间利用率上较差。
C++：哈希表
m0_61088872的博客
07-12 678
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 960
通过C++的基础来学习Python的异常处理
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
星羽空间
07-09 354
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
[C++]——同步异步日志系统（3）
plj521的博客
07-10 1544
从本篇开始，正式开始写同步异步日志系统

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值