C++线上课程1_13（const引用）

最新推荐文章于 2024-04-20 01:04:09 发布

web18224617243

最新推荐文章于 2024-04-20 01:04:09 发布

阅读量71

点赞数

分类专栏： java 后端文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/web18224617243/article/details/123480499

版权

java 同时被 2 个专栏收录

305 篇文章 15 订阅

订阅专栏

后端

15 篇文章 0 订阅

订阅专栏

本文详细探讨了C++编程中的关键概念，包括const引用的用法，如用作数组引用；模板函数的实例化和类型推演；左值和右值的区分，以及它们在常引用和右值引用中的应用；同时讲解了缺省函数的重要性，特别是运算符重载的规则和注意事项。通过示例代码，阐述了如何有效地利用这些特性来优化代码并提高程序效率。

摘要由CSDN通过智能技术生成

1.数组名

【类型（类型推演）和大小（替换）】

int main()
{
    int ar[10] = { 12,23,34,45,56,67,78,89,90,100 };

    sizeof(ar);//代表整个数组
    int(*p)[10] = &ar;//整个数组地址
    int(&br)[10] = ar;//引用数组
}

2.模板函数

（1）模板函数在编译的时候进行实例化，实例化时候进行模板推演规则

void Print_Ar(Type(&br)[N])
{
    for (int i = 0; i < N; ++i)
    {
        cout << br[i] << " ";
    }
    cout << endl;
}

（2）编译时候系统内部变化

处理整型变量

typedef int Type;
void Print_Ar<int,7>(Type(&br)[7])
{
    for (int i = 0; i < 7; ++i)
    {
        cout << br[i] << " ";
    }
    cout << endl;
}

非类型可以替换成宏，类型不能替换为宏，类型是一种重命名规则，非类型可以为替换规则。

3.左值和右值

（lvalue左值,xvalue僵王值,rvalue右值,prvalue纯右值）

（1）可以取地址的值为左值，不能取地址就为右值，右值引用不可寻址。右值分为字面常量和僵王值。

int a=10;//&a 左值，10 纯右值


int&& b=10;//右值引用
/*底层实现
b=10;
int tmp=10;
int* const b=&tmp;*/

（2）常引用可以引用字面常量

const int& a=10;

（3）右值引用和常引用区别？

#include<iostream>
using namespace std;
int fun()
{
    int a = 10;
    return a;
}
int main()
{
    int x = fun();
    int& b = fun();//
    const int& b = fun();//常引用内存空间中的值不可改变
    int&& d = fun();//可以改变内存空间存放临时量的地址
    return 0;
}

（4）内置类型，自己设计类型class（数据和方法），以及struct结构体类型。struct结构体类型介于两者之间，分为接口（纯虚函数）和数据。【虚拟内存管理】

为什么要设计类型？
优化代码，使程序运行速度加快，减少对内存的赋值和拷贝。
不允许使用memset，当有虚函数的时候，虚函数要指向虚表，就会移动虚表指针。内存拷贝函数谨慎使用。
有虚函数就有构造函数和赋值函数，没有虚函数和继承关系，成员无对象，只转移地址，不产生拷贝构造函数。
有内置类型和自己设计类型，要有拷贝构造函数。
如果没有赋值语句，系统就会产生缺省赋值语句，此语句无函数调用过程，
如果有赋值语句，不会形成现场保护。调动赋值语句，主函数分配栈帧，栈帧分配个赋值语句，不要把对象引用返回。

#include<iostream>
using namespace std;

//请完成赋值运算符重载
class Object
{
private:
    int num;
    int ar[5];
public:
    Object(int n, int val = 0) :num(n)
    {
        for (int i = 0; i < n; ++i)
        {
            ar[i] = val;
        }
    }
    Object(const Object& obj) :num(obj.num)//拷贝构造函数
    {
        for (int i = 0; i < 5; ++i)
        {
            ar[i] = obj.ar[i];
        }
    }

    Object& operator=(const Object & obj)//缺省构造函数
    {
        if (this != &obj)
        {
            num = obj.num;
            for (int i = 0; i < 5; ++i)
            {
                ar[i] = obj.ar[i];
            }
        }
        return *this;
    }
};
int main()
{
    Object obja(5, 23);
    Object objb(obja);
    Object objc(5);
    objc = obja;

    return 0;
}

4.缺省函数

（1）运算符重载函数的函数名必须为关键字operator加一个合法的运算符。在调用该函数时，将右操作数作为函数的实参。
（2）当用类的成员函数实现运算符的重载时，运算符重载函数的参数（当为双目运算符时）为一个或(当为单目运算符时)没有。运算符的左操作数一定是对象，因为重载的运算符是该对象的成员函数，而右操作数是该函数的参数。
3．单目运算符“++”和“–”存在前置与后置问题。
前置“++”格式为:

返回类型 类名::operator++(){……}

后置“++”格式为:

返回类型 类名::operator++(int){……}

后置“++”中的参数 int 仅用作区分，并无实际意义，可以给一个变量名，也可以不给变量名。(4)C++中只有极少数的运算符不允许重载。
在这里插入图片描述
重载运算符有以下几种限制
·不可臆造新的运算符
·不能改变运算符原有的优先级、结合性和语法结构,不能改变运算符操作数的个数
·运算符重载不宜使用过多
·重载运算符含义必须清楚，不能有二义性

前置++为单目，后置++为双目

Int& operator++()
{
    value += 1;
    return *this;
}
Int operator++(int)
{
    Int tmp = *this;
    ++* this;
    return tmp;
}


Int& operator+(const Int& it) const//对象和对象相加
{
    return Int(this->value + it, value);
}
Int& operator+(const int x) const//对象和整型变量相加
{
    return Int(this->value + x);
}
Int operator+(const int x, const Int& it)//整型变量和对象相加
{
    return it + x;
}
bool operator==(const Int& it) const//判断两个对象的值是否相等
{
    return this->value == it.value;
}
bool operator！ = (const Int & it) const//判断两个对象的值是否不相等
{
    return ！(*this == it);
}
bool operator<(const Int& it) const//小于
{
    return this->value < it.value;
}
bool operator>=(const int& it) const//大于等于
{
    return!(this < it);
}
bool operator>(const int& it) const//大于
{
    return this->value > it.value;
}
bool operator<=(const int& it) const//小于等于
{
    return!(this > it);
}

重载自加和加号运算符时，以函数方式进行。
自己设计的类型重载前置++和后置++时，