c++学习笔记（面向过程的编程风格）

发表于 |
字数统计: | 阅读时长 ≈

传值与传址

传值：只是讲其的值进行复制，再在函数里进行改变，但实际上，那个地址上的值没有任何变动

在调用函数时，会创建一块栈空间，保存了这个模块中的形参，一旦函数执行完毕，就会pop。

过程就是 sub mov add

当我们将vec[ix]这样的对象传入函数，默认情况下其值会被复制一份，成为意义上的形参。

传址：直接对地址上的值进行变动

inline函数

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
//函数定义为inline即:内联函数
inline char* dbtest(int a) {
    return (i % 2 > 0) ? "奇" : "偶";
} 

int main()
{
   int i = 0;
   for (i=1; i < 100; i++) {
       printf("i:%d    奇偶性:%s /n", i, dbtest(i));    
   }
}

上面的例子就是标准的内联函数的用法，使用inline修饰带来的好处我们表面看不出来，其实，在内部的工作就是在每个for循环的内部任何调用dbtest(i)的地方都换成了(i%2>0)?”奇”:”偶”，这样就避免了频繁调用函数对栈内存重复开辟所带来的消耗。

（不懂的可以拿poc去gcc，看汇编分析）

local static

1
2
3
4
5
6
7
8
9
10
11
12
13
const vector<int>*

fibon_seq(int size)

{

​	static vector<int>elems;

​	//函数工作逻辑在此处

​	return &elem;

}

此处elem被定义为局部静态变量，局部静态变量的含义是： 局部静态变量所处的内存空间，即使在不同的函数调用过程中，依然持续存在。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include "pch.h"
#include <iostream>
#include <vector>
#include <ostream>
#include <string>
using namespace std;

inline bool check(int size)
{
	return ((size <= 0 || size > 64) ? false : true);
}

const vector<int>*
Pentagonal_series(int pos)
{
	static vector<int> _elems;
	if (check(pos) && (pos > _elems.size()))
		for (int ix = _elems.size() + 1; ix <= pos; ix++)
			_elems.push_back((ix * (3 * ix - 1)) / 2);
	return &_elems;
}

//↓ pent就为局部静态变量，被赋值给了elem，在main中依然可以进行输出操作
bool Pentagonal(int size, int &elem)
{
	if (!check(size))
	{
		cout << "sorry!" << endl;
		elem = 0;
		return false;
	}
	const vector<int> *pent = Pentagonal_series(size);
	elem = (*pent)[size - 1];
	return true;

}

int main()
{
	int elem;
	if (Pentagonal(8, elem))
		cout << "element 8 is " << elem << '\n';

}

函数重载

函数名可以相同，参数不同（类型，个数）