C++ 编程基础

C++ 编程基础

---

1.函数

1.1 函数参数

C++ 的函数参数可以分为两种，一种是引用形参，一种非引用形参
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yGL5XqM7-1607960957408)(https://cdn.nlark.com/yuque/0/2020/svg/1291984/1594575703072-4b5eebb9-bd63-4fd8-9db5-3fe67bae8d47.svg)]

1.1.1 非引用形参

非引用形参通过复制传入实参实现形参的初始化，函数访问调用所传递的实参本身，因此不会改变实参的值。
指针形参
如果函数参数是非const 类型的指针，可以通过指针对该对象进行赋值，修改指针所指向对象的值。

void reset(int *p)
{
	*ip = 0; // 直接改变了ip对象的值
    ip = 0; // 这里只是改变了局部变量的值，但是参数并没有发生改变
}

如果需要保护指针指向对象的值，则需要对参数添加const。
const形参
在C++ 中为了更好兼容C语言，具有const 的形参或非const形参的函数并无区别
非引用参数的局限

• 无法修改函数传入实参的值
• 大型对象传入的时候，复制对象的传入的时间和存储消耗相对较大
• 有的场景下没有办法实现对象的复制

通常以上情况，都需要将形参定义为引用或者指针类型

1.1.2 引用形参

引用形参使用的几种场景

1. 在C语言中我们通常使用指针实现对实参的访问，但是C++中，使用形参则相对更加的安全和自然。如果涉及除了需要返回除了返回值之外的更多的信息，也可以使用引用参数。
2. 大型对象操作也需要使用引用参数。
3. 如果函数不需要对参数进行修改，则定义为const引用，非const的引用在使用时不太灵活，这样的形参既不能用于const对象的初始化，也不能字面值或产生右值的表达式实参初始化。
4. 传递指向指针的引用

//swap vlaues of two pointers to int 
void ptrswap(int *&v1, int *&v2)
{
	int *tmp = v2;
    v2 = v1;
    v1 = tmp;
}

int main()
{
	int i = 10;
    int j = 20;
    int *pi = &i;
    int *pj = &j;
    cout<<"Before ptrswap():\t*pi: "<< *pi <<"\t*pj: "<< *pj<<endl;
    ptrswap(pi, pj);
    cout<<"After ptrswap():\t*pi: "<< *pi << "\t*pj: "<< *pj<<endl;
    return 0;
}
/*
* Before ptrswap(): *pi: 10       *pj: 20
* After ptrswap(): *pi: 20        *pj: 10
*/

形参 **int *&v1 **从右到左理解，v1是一个引用，与指向int型对象的指针关联，也就是v1只是传递进ptrswap 函数的任意指针的别名。

1.1.3 vector及其他容器类型参数

从避免复制vector的角度出发，应考虑将形参声明为引用类型。然而实际上，C++程序员更多倾向于传递需要处理元素的迭代器来传递容器

void print(vector<int>::const_iterator beg, vector<int>::const_iterator end)
{
	while (beg != end) {
    	cout<<*beg++;
        if (beg != end) {
        	cout<< " ";
        }
    }
    cout<<endl;
}

1.1.4 数组作为形参

数组的两个性质

• 不能复制数组
• 使用数组名字时，数组名会转化为指向其第一个元素的指针

数组形参的定义

void PrintValues(int *) { ... }
void PrintValues(int []) { ... }
void PrintValues(int[10]) { ... }

函数形参中不要定义数组长度，

void PrintValues(const int a[10])
{
	for(size_t i = 0; i != 10; ++i) {
    	cout<<ia[i]<<endl;
    }
}

如上函数中传递的数组至少含有10个元素，但是C++并没与任何机制强制实现这个假设。如下的调用都是合法的

int main()
{
    int i = 0, j[2] = {0 , 1};
    PrintValues(&i);
    PrintValues(j);
    return 0;
}

当编译器检查数组形参关联的实参时，只会检查实参是不是指针，指针的类型和数组元素的类型是否匹配，而不会检查数组的长度

对于数组参数，不要传入数组长度，但是我们通过引用传递数组长度，编译器不会将实参转换为指针，而是传递数组的引用本身。这种情况下，数组大小成为实参和形参类型的一部分，编译器会检查实参大小与形参大小是否匹配。
对于数组形参的元素，如果不需要修改内容，应该将形参定义为指向const对象的指针。

任何处理数组的程序都要确保程序停留在数组边界内

数组大小保证的方式

• 传入第一个元素和最后一个的下一个指针的位置
• 显式传递表示数组大小的形参

什么时候用指针形参？什么时候使用引用形参？两者的优点和缺点_
答：当函数需要处理数组且不依赖数组长度的时候应当使用指针形参，其他情况都使用引用形参。可以传递任意长度的数组实参来调用函数，但是不能依赖于数组长度，否则容易造成数组内存越界访问，而产生错误导致崩溃。引用传递中依赖数组的长度是安全的，缺点是限制了实参数组，只能使用长度匹配的实参来调用函数。

1.1.5 返回值

易错点

循环语句块中有return,但是循环语句块之后结束后没有return

• 允许主函数main没有返回值就结束，编译器会隐的插入return 0
• 如果返回值是非引用类型，当需要一个地方存储运算结果，编译器会创建一个没有命名的临时对象temporary object
• 当函数返回引用类型时，没有复制返回值，返回的是对象本身

如下函数

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

• 千万不能返回局部对象的引用，因为这时候资源已经释放，确保引用返回安全，编码时自问这个引用指向的哪个之前存在的对象
• 也千万不要返回局部对象的指针，如果函数资源已经释放，返回的指针就将变成指向不再存在对象的野指针

1.1.6 声明

头文件声明，源文件定义

默认实参声明，默认实参通常在头文件中指定

string screenInit(string::size_type height = 24, string:;size_type width = 80, char backgroud = ' ');

1.1.7 局部对象

自动对象
只有当定义它的函数被调用的时候才存在的对象，称之为自动对象

静态局部对象
对象一旦被创建，在程序结束前都不会被撤销, 如下

#include <iostream>

using namespace std;
size_t count_calls()
{
    static size_t ctr = 0;
    return ++ctr;
}
int main(int argc, char* argv[])
{
    for (size_t i = 0; i != 10; i++) {
        cout<<count_calls()<<" ";
    }
    cout<<endl;
    return 0;
}
/*
output: 
1 2 3 4 5 6 7 8 9 10
*/

1.2 内联函数

1.2.1 内联函数的定义

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

类似上面这种的小函数，在理解，修改，测试，重用上相对我们表达式有着优势，但是在调用上却是相对表达式慢一点，函数调用前需要保存寄存器，并在返回时恢复，复制实参，程序还必须转向一个新的对象执行。 为了同时拥有表达式和小函数的优势，内联函数就出现了
内联函数的定义如下：

inline const string& shorterString(const string &s1, const string &s2) 
{	
	return s1.size() < s2.size() ? s1 : s2;
}	

内联函数会在程序编译时内联的展开,即

cout<< shorterString(s1, s2)<<endl;

等同于

cout<< (s1.size() < s2.size() ? s1 : s2) << endl;

说明

函数加上了inline的关键字，但是函数是否进行内联展开，这个是编译器决定。inline的作用是建议编译器进行内联展开

注意

内联函数应该定义在头文件中

1.3 静态函数

如果一个类定义了一个私有的静态成员，我们要访问它，就需要定义一个静态的pulic方法。
类似如下：

#include <iostream>

using namespace std;
class Something
{
private:
    static int s_value;
public:
    static int getValue() { return s_value; } // 静态成员函数
};

int Something::s_value{ 1 }; // 初始化

int main()
{
    std::cout << Something::getValue() << '\n';
}

• 静态函数没有附加到任何对象，所以静态函数中也不会有*this 指针
• 相对非静态函数，静态函数可以直接使用类中的其他静态成员
• 纯静态类，只能实例化出一个对象，无法实例化出两个相互独立的纯虚类的对象
• 纯静态类基本可以等价于该命名空间里的全局对象
• C++ 不支持静态构造方法

1.4 构造函数

构造函数是特殊的成员函数，只要创建类类型的新对象，都需要执行构造函数。

• 构造函数可以被重载
• 实参决定使用哪个构造函数
• 构造函数自动执行
• 构造函数不能声明为const

1.4.1 构造函数的初始化式

构造函数初始化列表以一个冒号开始，接着是一个以逗号分割的数据成员列表，每个数据成员后面跟一个放在圆括号中的初始化式。从概念上讲，构造函数分两个阶段执行1.初始化阶段，2.普通的计算阶段。

不管成员是否在构造函数初始化列表中显式初始化，类类型数据成员总在初始化阶段初始化，初始化发生在计算阶段开始之前。