C++函数进阶

函数进阶

using 指令尽量不要出现在头文件中

因为在预编译的过程中，所有引用该头文件的文件都会再次申明出现这条using指令

顶层const和底层const

指针

由于指针本身是一个对象，所以指针所指向的对象是不是常量和指针变量本身是不是常量是两个问题：

• 顶层const是指指针本身是一个常量，申明一个常量指针可以通过以下方式:

int a = 1;
int *const var = &a;
//此处报错，表达式必须是可修改的左值
var = 0;

• 底层const是指指针所指向的对象是一个常量，不允许修改，他的申明方式如下:

  int a = 1;
  const int *var = &a;
  //此处报错，表达式必须是可修改的左值
  *var = 2;
  //没问题，可以编译通过
  var = 0;
  

引用

在使用const引用时候,其实他的底层const和底层cons方式定义方式是相反的

//定义一个const底层引用
string s = "hello, word"
const string &s1 = s
//定义一个顶层引用
string& const s2 = s

重载和const形参

一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来

void test(int){};
//无法和第一个函数进行区分
void test(const int){};

void test(int*){};
//申明的顶层const无法和第三个进行区分
void test(int *const){};

如果形参是某种类型的指针或者引用，则通过区分其指向的常量对象还是非常量对象可以实现函数重载,此时的const是底层,引用本来就是为了简化指针的操作，所以此处的引用参数实际上还是底层const

void test(int &){};
void test(const int &){};
void test(int*){};
void test(const int*){};

内联函数

内联函数可以避免函数调用造成的开销，内联函数在运行的过程中，不会执行现场保护等操作，而是在调用点直接将函数内联的展开，因此这样的函数更加适合于规模小、流程直接、频繁调用的函数。
最常用的应用场景就是较为复杂且使用较多的函数表达式，将这样的表达式写成内联函数，既不会造成额外的函数调用和返回造成的开销，也能保证代码的可读性

assert(expr)

assert属于一个预处理宏，主要用于协助调试，当assert后面的表达式返回为假时，输出信息程序终止

函数中返回局部变量的引用或者指针

由于函数在调用的过程中是处于自己的栈中，函数一旦结束弹栈的时候，所有相关的局部变量都会被销毁，返回局部变量的指针以及引用是无效的，因为他们都指向了一个被标记为"未占用的空间"，谁都不清楚函数在结束后这一段空间会发生什么

也有一个例外情况，由于c++动态内存的特性,通过new申请的内存都是位于堆上，位于堆上的空间不会自动释放，只能由我们通过delete释放，所以，如果我们希望在函数中返回指针等操作，是可以用new关键字在堆上申请空间,在函数返回的时候将指针返回出去，这样其实是可行的

#include <iostream>
#include <string>
using std::cout;
using std::cin;
using std::string;
const string* getString()
{
    return new string(10,'c');
}
int main()
{
    const string* s = getString();
    delete s;
    return 0;
}

这个示例其实还有一个知识点:
可以看到我定义的函数返回的是一个string对象的底层const,也就意味着这个指针指向的对象是不可变得，因此调用函数后接受返回值也必须是一个底层const

函数的返回值和参数

这里我想记录的其实还是const带来的问题
之前说过底层const的引用或者指针是不会允许通过任何途径修改所指向的空间的内容(这其实只是const变量自己一厢情愿的而已，怎么听起来有点悲惨qaq)

string  s = "12311";
const string &s1 = s;
//可以通过s修改
s = "1";
cout << s1;
//通过s1修改是不被允许的，这下你该信我是一个变量一厢情愿了吧
s1 = "1";

所以申明为底层const的对象绝不可能赋值给一个普通变量
来点简单的例子:

string &s= "12313";

那么这么写一定是错误的,因为右值是一个字面值，他的类型是const char*，一个底层const怎么能够赋值给普通的引用呢?

在看一个例子

#include <iostream>
#include <string>
using std::cout;
using std::cin;
using std::string;
void printString(string &s)
{
    cout << s;
}
int main()
{
    printString("1412414");

    return 0;
}

这个原理实际上与第一个类似，但是写出这样的代码人且不明白原因的人应该不少吧?

最后一个例子

string& getString()
{
    return "ad141";  
}

应该不用解释了吧
所以说引用作为参数或者返回值虽然可以减少拷贝带来的效率消耗，但是使用的时候同时还会有许多注意点

const_cast

前面说过const与否只是变量自己一厢情愿，所以从const到非const的转换也是可行的，主要也就是用到一个函数const_cast<>(),这个函数主要用于调整限定符，在重载场景下最为常用

可以通过相互转换(获取)
const string& <> string&
string& const <> string&
const string* <==> string*
string* const <=> string* const