C++基础 | C++对C语言的拓展

最新推荐文章于 2025-03-18 20:02:11 发布

青春猪头少年_

最新推荐文章于 2025-03-18 20:02:11 发布

阅读量152

点赞数

本文链接：https://blog.youkuaiyun.com/weixin_41017788/article/details/105266036

版权

引用

引用相当于常指针
如 int &a和int* const a

引用的规则

1 引用没有定义,是一种关系型声明。声明它和原有某一变量(实体)的关系。故而类型与原类型保持一致,且不分配内存。与被引用的变量有相同的地址。
2 声明的时候必须初始化,一经声明,不可变更。
3 可对引用,再次引用。多次引用的结果,是某一变量具有多个别名。
4 &符号前有数据类型时,是引用。其它皆为取地址。

int main(void)
{
int a,b;
int &r = a;
int &r = b; //错误,不可更改原有的引用关系
float &rr = b; //错误,引 类型不匹配 cout<<&a<<&r<<endl; 
//变量与引用具有相同的地址。
int &ra = r; //可对引用更次引用,表 a 变量有两个别名,分别是 r 和 ra
return 0; 
}

引用的意义

1)引用作为其它变量的别名而存在，因此在一些场合可以代替指针
2)引用相对于指针来说具有更好的可读性和实用性

#include<iostream>
using namespace std;
void swap1(int &a, int &b){
    int tmp;
    tmp = a; a = b;
    b = tmp;
}
void swap2(int *a,int *b){
    int tmp;
    tmp=*a;
    *a=*b;
    *b=tmp;
}
int main() {
    int a = 3,b = 5;
    cout<<"a = "<<a<<"b = "<<b<<endl;
    swap1(a,b);
    cout<<"a = "<<a<<"b = "<<b<<endl;
    swap2(&a,&b);
    cout<<"a = "<<a<<"b = "<<b<<endl;
    return 0;
}

运行结果
a = 3b = 5
a = 5b = 3
a = 3b = 5

引用作为函数的返回值(引用当左值)

#include <iostream>
using namespace std;
int& getA1() {
    int a;
    a = 10;
    return a;
}
int& getA2(int &a) {
    a = 10;
    return a;
}

int main(void)
{
    int a1 = 0;
    int a2 = 0;

    int &a3 = getA1();

    cout <<"a3 = " <<a3<<endl; //结果为32767，由于是栈的引 ，内存非法
    //getA1返回的不应该是形参

    int &a4 = getA2(a1); //这样的才可以正确返回引用，结果为10

    cout <<"a4 = " <<a4<<endl; 
    
   
return 0; 
}

指针引用

#include <iostream>
using namespace std;
struct Teacher
{
    char name[64];
int age ; 
};
int getTeacher(Teacher **p) {
    Teacher *tmp = NULL;
    if (p == NULL){
        return -1;
    }
    tmp = (Teacher *)malloc(sizeof(Teacher));
    if (tmp == NULL){
        return -2;
    }
    tmp->age = 33;  
    // p是实参的地址 *实参的地址 去间接的修改实参的值 
    *p = tmp;
    return 0; 
}
//指针的引用做函数参数
int getTeacher2(Teacher* &myp) {
//给myp赋值 相当于给main函数中的pT1赋值
    myp = (Teacher *)malloc(sizeof(Teacher)); 
    if (myp == NULL){
    return -1; 
    }
    myp->age = 36;
    return 0;
}
void FreeTeacher(Teacher *pT1){
    if (pT1 == NULL){
    return ; 
    }
    free(pT1); 
}

//getTeacher和getTeacher2效果一致
int main(void)
{
    Teacher *pT1 = NULL;

    getTeacher(&pT1); 
    cout<<"age:"<<pT1->age<<endl; 
    FreeTeacher(pT1);
//引用的本质 间接赋值后2个条件 让c++编译器帮我们程序员做了。
 
    getTeacher2(pT1);
    cout<<"age:"<<pT1->age<<endl;
    FreeTeacher(pT1);
return 0; 
}

const引用

const 引用有较多使用。它可以防止对象的值被随意修改。因而具有一些特性。
(1)const 对象的引用必须是 const 的,将普通引用绑定到 const 对象是不合法的。这个原因比较简单。既然对象是 const 的,表示不能被修改,引用当然也不能修改,必须使用 const 引用。实际上,
const int a=1;
int &b=a;
这种写法是不合法的,编译不过。
(2)const 引用可使用相关类型的对象(常量,非同类型的变量或表达式)初始化。这个是 const 引用与普通引用最大的区别。
是合法的。

  也是合法的。

const int &a=2;
double x=3.14;
const int &b=a;
const int &b=x;(这里要注意，因为不是同类型，此时b的地址和x的地址已经不一样了，开辟了一个空间存放强制转换后的值）

#include <iostream>
using namespace std;

int main(void)
{
double val = 3.14;
const int &ref = val;
double & ref2 = val;
cout<<ref<<" "<<ref2<<endl;//3 3.14
val = 4.14;
cout<<ref<<" "<<ref2<<endl;//3 4.14
return 0; 
}

结论:
1)const int & e 相当于 const int * const e
2)普通引用相当于 int *const e
3)当使用常量(字面量)对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名
4)使用字面量对const引用初始化后，将生成一个只读变量
const int &ref =3;//地址0x00007fff5fbffe5c

inline內联函数

#include <iostream>
using namespace std;
inline void func(int a)
{
a = 20;
    cout << a <<endl;
}
int main(void)
{
func(10);
 /*
//编译器将内联函数的函数体直接展开
 {
        a = 20;
        cout << a <<endl;
  }
*/
return 0; 
}

特点:
1)内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器会直接忽略内联请求。
2)C++编译器直接将函数体插入在函数调用的地方。
3)内联函数没有普通函数调用时的额外开销(压栈，跳转，返回)。
4)内联函数是一种特殊的函数，具有普通函数的特征(参数检查，返回类型等)。

内联函数由编译器处理，直接将编译后的函数体插入调用的地方,宏代码片段由预处理器处理，进行简单的文本替换，没有任何编译过程(可能会有bug)。

C++中内联编译的限制

不能存在任何形式的循环语句
不能存在过多的条件判断语句
函数体不能过于庞大
不能对函数进行取址操作
函数内联声明必须在调用语句之前

编译器对于内联函数的限制并不是绝对的，内联函数相对于普通函数的优势只是省去了函数调用时压栈，跳转和返回的开销。因此，当函数体的执行开销远大于压栈，跳转和返回所用的开销时，那么内联将无意义。

优点:避免调用时的额外开销(入栈与出栈操作)
代价:由于内联函数的函数体在代码段中会出现多个“副本”,因此会增加代码段的空间。
本质:以牺牲代码段空间为代价,提高程序的运行时间的效率。
适用场景:函数体很“小”,且被“频繁”调用。

內联函数一般很少用

默认参数和占位参数

默认参数

单个默认参数时：

//1 若 你填写参数,使 你填写的,不填写默认 
void myPrint(int x = 3)
{
    cout<<"x: “<<x<< endl;
}

多个默认参数时，一旦某个参数使用默认参数，后面的都要使用

占位参数

#include <iostream>
/*
  函数占位参数
  占位参数只有参数类型声明， 没有参数名声明
   般情况下，在函数体内部 法使 占位参数
*/
int func(int a, int b, int)
{
return a + b; }
int main() {
    func(1, 2); //error, 必须把最后 个占位参数补上。 
    printf("func(1, 2, 3) = %d\n", func(1, 2, 3));
    return 0;
}
//C++可以声明占位符参数，占位符参数一般般用于程序扩展和对C代码的兼容

重载

函数形参列表（参数的个数，参数的类型，参数顺序）
构成函数重载的条件是：函数名相同，函数形参列表不同。
返回值的类型不是条件。

编译器调用重载函数的准则:

1.将所有同名函数作为候选者
2.尝试寻找可行的候选函数
3.精确匹配实参
4.通过默认参数能够匹配实参
5.通过默认类型转换匹配实参
6.匹配失败
7.最终寻找到的可行候选函数不唯一，则出现二义性，编译失败。
（若形参涉及默认参数，可能会导致二义性）
8.无法匹配所有候选者，函数未定义，编译失败。

重载底层实现

C++利用 name mangling(倾轧)技术,来改名函数名,区分参数不同的同名函数。
实现原理:用 v c i f l d 表示 void char int float long double 及其引用。

void func(char a);                            // func_c(char a)
void func(char a, int b, double c); //func_cid(char a, int b, double c)

函数指针的基本语法

插入typedef的一些用法：
typedef int INT_ARRAY_10[10]; //定义一个长度为10的int数组
//别名为INT_ARRAY_10
如INT_ARRAY_10 a;

为函数指针定义新的名称
typedef int (*MyFUN)(int a，intb);
MyFUN是指向函数的指针类型的新别名，int是函数返回类型
（int a, int b)是参数列表

（找时间好好研究更多有关细节https://www.cnblogs.com/seventhsaint/archive/2012/11/18/2805660.html）

// 法 一:
//声明一 个函数类型
typedef void (myTypeFunc)(int a,int b);
//定义 一个函数指针
myTypeFunc *myfuncp = NULL; //定义一个函数指针 这个指针指向函数的  地址
// 法二 :
//声明 一个函数指针类型
typedef void (*myPTypeFunc)(int a,int b) ; //声明了一个指针的数据类型
 //定义一个函数指针
myPTypeFunc fp = NULL; //通过 函数指针类型 定义了 一个函数指针 ,
// 法三:
//定义一个函数指针 变量
void (*myVarPFunc)(int a, int b) = NULL;

函数指针与函数重载的结合

int func(int x) // int(int a)
{
return x;
34
}
int func(int a, int b)
{
return a + b; }
int func(const char* s)
{
   return strlen(s);
}
typedef int(*PFUNC)(int a);             // int(*)(int a)
typedef int(*PFUNC2)(int a, int b); // int(*)(int a, int b)

函数重载总结：
重载函数在本质上是相互独立的不同函数。（在底层命名是不同的）
函数的函数类型是不同的
函数返回值不能作为函数重载的依据
函数重载是由函数名和参数列表决定的。