猿创征文 |【C++】面向对象之微观部分——类的组成(中)

已于 2022-09-18 20:13:21 修改
阅读量1.4k 收藏 36
点赞数 40
分类专栏： C++ 文章标签： c++ 开发语言 c语言 经验分享 猿创征文
于 2022-09-09 00:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65835264/article/details/126753521
版权
本文详细介绍了C++中的常对象与常函数，包括它们的定义、语法关系和意义，以及如何使用`mutable`关键字。接着探讨了类中的静态成员函数，解释了静态成员变量和静态成员函数的特性和使用场景。此外，文章深入讲解了拷贝构造的概念，分析了深拷贝和浅拷贝的区别，并通过示例展示了如何处理堆内存的对象拷贝问题。最后，讨论了匿名对象的产生和生命周期。
摘要由CSDN通过智能技术生成

文章目录

前言

打算做一个C++知识体系的专栏，干货较多，整理较慢，会定期产出，想学习可以关注一下。

本文承接上篇文章面向对象之微观部分——类的组成(上)感兴趣的可以了解一下。

一、常对象与常函数

1.1 常对象与常函数的定义形式

常对象： 就是const修饰的类对象，常引用也是常对象。

const + 类型(引用类型) 对象名(构造函数的实参表);
类型(引用类型) const + 对象名(构造函数的实参表);
常对象：只能以读取的方式访问类中的属性，而不能修改类中的属性。
起到作用：保护与安全机制。

注：

  1. 常对象只能调用常成员函数；
  2. 非常对象优先调用非常成员函数，如果没有，也可以调用常成员函数；
  3. 如果一个普通对象被常引用给引用了，那么通过这个对象本身去访问成员函数是通过非常对象的方式访问，而通过引用访问成员函数是用过常对象的方式访问。

常函数： 就是const修饰的类中的成员函数就叫常函数。

class  类名
{
    //类中的成员函数 + const修饰
    返回值  函数名(形参列表)const
    {
        //常成员函数，简称常函数。    
    }
};

注：

  1. 在常成员函数中，不允许修改成员变量的值；
  2. 常成员函数可以重载，常成员函数和非常成员函数也构成重载关系。
  3. 常成员函数的const本质上修饰的是 this 指针，
    this 指针本来应该是 ： 类名 * const this;
    常成员函数的this指针应该是：const 类名 * const this;

常函数的特点是：
在常函数中只能以读取类中属性的方式进行访问，而不能对类中的属性进行写操作。
常函数的意义：
保护类中的属性或形参变量不会在常函数体内被修改，起到一种保护作用。

mutable关键字：mutable关键字修饰的成员变量允许在常成员函数中修改；

代码示例：

#include <iostream>
using namespace std;

class Student
{
private:
    string name;
    int age;
    mutable int id;//允许在常函数中修改
public:
    Student(string _name,int _age,int _id):name(_name),age(_age),id(_id)
    {

    }
    void show()const
    {
        cout << "常成员函数" << endl;
        //常成员函数不能修改成员变量的值
        //this->age=100;错误的
        this->id=1003;//可以修改因为有mutable修饰
        cout << "姓名：" << name << " 年龄：" << age <<" 学号：" << id << endl;
    }
    //与上面构成重载关系
    void show()
    {
        cout << "普通成员函数" << endl;
        cout << "姓名：" << name << " 年龄：" << age <<" 学号：" << id << endl;
    }

};
int main()
{
    Student s1("张三",20,1001);
    s1.show();
    const Student s2("夜猫徐",20,1002);
    s2.show();
    const Student& a=s1;
    a.show();//通过引用访问成员函数

    return 0;
}

结果展示：
在这里插入图片描述
总结：

  1. 在常成员函数中，不允许修改成员变量的值，mutable关键字修饰的成员变量允许在常成员函数中修改。
  2. 常成员函数和非常成员函数也构成重载关系。
  3. 一个普通对象被常引用给引用了，通过引用访问成员函数是用过常对象的方式访问。

1.2 常对象与常函数语法关系与意义

语法关系：
常对象，只能调用常函数，而不能调用普通函数。因为普能函数有写的属性。
普通对象，当然可以调常函数。

代码验证：

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int age;
public:
    Stu(string _name,int _age):name(_name),age(_age)
    {
        cout << "Stu中的有参构造" << endl;
    }
    ~Stu()
    {
        cout << "Stu的析构" << endl;
    }
    int getage()const//常函数
    {
        //this->age=100;这种方式报错
        //常函数是不能修改类中的属性的
        return this->age;
    }
    string getname()const
    {
        //this->name="lisi";
        return this->name;
    }
};
bool compare(const Stu& stu1,const Stu& stu2)
{
    //常对象只能调用常函数。
    return stu1.getage()>stu2.getage();
}
int main()
{
    Stu stu1("zhangsan",20);
    Stu stu2("yemaoxu",18);
    if(compare(stu1,stu2))
    {
        cout << "zhangsan大" << endl;
    }
    else
    {
        cout << "yemaoxu大" << endl;
    }
    return 0;
}

结果展示：
在这里插入图片描述
总结：

  1. 常对象只能调用常函数，不可以调用普通函数，因为普通函数有修改类中属性的权限。
  2. 常函数只能读取类中的成员属性，而不可以修改类中成员函数。
    普通对象是可以调用常函数的。

常对象与常函数在程序设计中的意义：

const修饰的常对象及常函数起到了对，对象中的数据的保护，使大型工程代码更健壮更安全。

二、类中静态成员函数

2.1 回顾静态成员变量的特点

我们知道static修饰的成员对象，是对成员对象存储形式的修饰，他存储在静态区。
必须在类中声明，类外初始化，才能定义空间。

所以他具有以下特征：

  1. 该静态成员对象是属于类的，而非某个对象的。
  2. 他不依赖于某个对象，可以直接使用类名 + :: 域名访问符直接访问。
  3. 该静态成员对象为类的所有对象所共享一份。
  4. 该静态成员不占用类对象的空间。

2.2 类中的static修饰的静态成员函数

加了static修饰的成员函数，他不并是修饰函数的存储形式，是修饰的他的函数级别。

由static修饰的成员函数变成了一个全局函数，只不过是隐藏在类的作用域之中而已。
当这个成员函数被升级为全局函数之后，类中对象在堆上或在栈上什么时候产生就与之没有关系了，因为它没有了this指针。
且因为静态成员函数没有了this指针，所以无法访问类中非静态的属性，只能访问类中的静态属性。
所以静态成员函数也具有静态成员变量的特性，他不依赖于某个对象的调用，他是为整个类而服务，而非某个对象。

代码示例：

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int age;
    
public:
    static int count;
    Stu(string name, int age)
    {
        this->name = name;
        this->age = age;
        count++;
    }
    static void getCount()
    {
        //cout << name <<endl;错误，静态成员函数没有this指针
        cout << count <<endl;//只能访问静态成员变量
    }
};
//类中静态成员变量类外进行初始化的方式：
int Stu::count;

int main()
{
    Stu stu1("yemaoxu",18);
    Stu stu2("zhangsan",20);
    stu1.getCount();//访问静态成员函数的方式1：通过类对象访问
    Stu::getCount();//访问静态成员函数的方式2：通过类名直接访问
    //cout << Stu::count << endl;//私有属性时不可以访问，公有时可以通过类对象访问
    cout << stu1.count << endl;//静态成员变量的访问方式1：在静态成员变量是公有时可以通过类对象访问
    Stu::count=5;//静态成员变量的访问方式2：在静态成员变量是公有时通过类名直接访问
    cout << Stu::count << endl;
    stu1.count=10;//通过stu1修改count,通过stu2访问也会发生变化
    cout << stu2.count << endl;

    return 0;
}

结果展示：
在这里插入图片描述
总结：

  1. 静态成员变量的访问方式1：在静态成员变量是公有时可以通过类对象访问。
    静态成员变量的访问方式2：在静态成员变量是公有时可以通过类名直接访问。
  2. 访问静态成员函数的方式1：公有时通过类对象访问。
    访问静态成员函数的方式2：公有时通过类名直接访问。
  3. 静态成员函数没有this指针，只能访问静态成员变量。
  4. 类中静态成员变量类外进行初始化的方式：int Stu::静态变量名;

为什么要使用静态成员变量？
为了让成员变量的存在不依赖于任何类对象。
为什么要使用静态成员函数？
为了让函数逻辑的执行不依赖于任何类对象。

三、拷贝构造与深浅拷贝

3.1 编译器默认提供的拷贝构造格式

函数名：与类同名
返回值：没有
形参表：const 类名 &

类名(const 类名& other)
{
    this->属性  = other.属性;
    ...
}

3.2 拷贝构造的调用时机

  1. 当定义本对象，使用已经存在的对象进行初始化时，编译器自动调用拷贝构造。
  2. 当函数参数为类类型时，则自动调用类中的拷贝构造。
  3. 当函数返回值为类类型时，则自动调用类中的拷贝构造。

3.3 拷贝构造之深浅拷贝

编译器会默认使用浅拷贝，第一性能方面浅拷贝性能更高，第二，编译器没有考虑到类中有属性指针指向堆区的情况。
如果有类中属性指针指向堆区，那么就必须进行深拷贝的改造。

3.3.1 浅拷贝

代码示例：

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int age;
public:
    //有参构造
    Stu(string name, int age)
    {
        this->name = name;
        this->age = age;
    }
    //编译器给我提供默认拷贝构造语法形式：这种简单的值的传递也称之为浅拷贝。浅拷贝对计算机性能消耗较低。
    Stu(const Stu& other):name(other.name),age(other.age)//拷贝构造函数也可以有初始化表
    {
        //this->name=other.name;
        //this->age=other.age;
    }
    void show()
    {
        cout << "姓名：" << name << " 年龄：" << age << endl;
    }
};
int main()
{
    Stu s1("夜猫徐",18);
    s1.show();
    //显式调用类中拷贝构造，当类中并没有提供这个构造，编译器会自动给生成一个拷贝构造.
    //这个编译器会自动给生成的拷贝构造就是上面我们写的拷贝构造语法形式实现的。
    Stu s2(s1);
    s2.show();
    //隐式调用类中的拷贝构造。
    Stu s3 = s1;
    s3.show();
    Stu *p=new Stu(s1);
    p->show();
    delete p;
    p=nullptr;
    return 0;
}
}

结果展示：
在这里插入图片描述
总结：

  1. 这种简单的值的传递也称之为浅拷贝。浅拷贝对计算机性能消耗较低。
  2. 编译器会给我提供默认拷贝构造，如果你不自己提供，则默认的是浅拷贝。
  3. 隐式调用类中的拷贝构造Stu s3 = s1;
  4. 显式调用类中拷贝构造Stu s2(s1);
  5. 显示和隐式调用在没有自己提供拷贝构造也是可以实现的，因为调用了默认的拷贝构造。
  6. 拷贝构造函数也可以有初始化表。

3.3.2 深拷贝

有类中属性指针指向堆区，那么就必须进行深拷贝的改造。

改造代码示例：

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int age;
    int *p;
public:
    //有参构造
    Stu(string name, int age)
    {
        this->name = name;
        this->age = age;
        this->p=new int[20];//有类中属性指针指向堆区,升级为深拷贝
        cout << "Stu的构造"  << endl;
    }
    //编译器给我提供默认拷贝构造语法形式：这种简单的值的传递也称之为浅拷贝。浅拷贝对计算机性能消耗较低。
    Stu(const Stu& other)/*:name(other.name),age(other.age)*/
    {
        this->name=other.name;
        this->age=other.age;
        //指针成员也会只做简单的赋值，相当于两个对象的指针成员指向的是同一块空间，调用析构函数释放时，
        //就会出现 double free的问题不能简单的使用浅拷贝，要升级为深拷贝
        //深拷贝实现步骤
        //1.开辟新空间
        this->p=new int[20];
        //2.拷贝数据
        //memcpy(this->p, other.p,sizeof(int[20]));
        //memove针对小型嵌入设备的开发。
        memmove(this->p,other.p,sizeof(int[20]));//memmove有一种安全机制。
        cout << "Stu的拷贝构造" << endl;
    }
    ~Stu()
    {
        delete []p;
        cout << "Stu的析构"  << endl;
    }
    void show()
    {
        cout << "姓名：" << name << " 年龄：" << age << endl;
    }
};
int main()
{
    Stu s1("夜猫徐",18);
    s1.show();
    //显式调用类中拷贝构造，当类中并没有提供这个构造，编译器会自动给生成一个拷贝构造.
    //这个编译器会自动给生成的拷贝构造就是上面我们写的拷贝构造语法形式实现的。
    Stu s2(s1);
    s2.show();
    //隐式调用类中的拷贝构造。
    Stu s3 = s1;
    s3.show();
    return 0;
}

结果展示：
在这里插入图片描述
总结：

  1. 当有类中属性指针指向堆区,不可以使用默认拷贝和浅拷贝，应该使用深拷贝。不然在释放时会出现double free的错误。
  2. 浅拷贝升级为深拷贝的步骤 ：1.开辟新空间 2.拷贝数据到新空间中

3.3.3 拷贝构造带来的问题即解决方式

以下面代码为负面例子：

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;
    int age;
    int *p;
public:
    //有参构造
    Stu(string name, int age)
    {
        this->name = name;
        this->age = age;
        this->p=new int[20];//有类中属性指针指向堆区,升级为深拷贝
        cout << "Stu的构造"  << endl;
    }
    //编译器给我提供默认拷贝构造语法形式：这种简单的值的传递也称之为浅拷贝。浅拷贝对计算机性能消耗较低。
    Stu(const Stu& other)/*:name(other.name),age(other.age)*/
    {
        this->name=other.name;
        this->age=other.age;
        //指针成员也会只做简单的赋值，相当于两个对象的指针成员指向的是同一块空间，调用析构函数释放时，
        //就会出现 double free的问题不能简单的使用浅拷贝，要升级为深拷贝
        //深拷贝实现步骤
        //1.开辟新空间
        this->p=new int[20];
        //2.拷贝数据
        //memcpy(this->p, other.p,sizeof(int[20]));
        //memove针对小型嵌入设备的开发。
        memmove(this->p,other.p,sizeof(int[20]));//memmove有一种安全机制。
        cout << "Stu的拷贝构造" << endl;
    }
    ~Stu()
    {
        delete []p;
        cout << "Stu的析构"  << endl;
    }
    void show()
    {
        cout << "姓名：" << name << " 年龄：" << age << endl;
    }
    int getage()
    {
        return this->age;
    }
};
Stu compare_age(Stu stu1,Stu stu2)
{
    return stu1.getage()>stu2.getage()?stu1:stu2;
}
int main()
{
    Stu s1("夜猫徐",18);
    s1.show();
    Stu s4("zhangsan",20);
    cout << "-------------------" << endl;
    compare_age(s1,s4).show();
    return 0;
}

优化后代码：
其他不遍，加上引用。

Stu& compare_age(Stu& stu1,Stu& stu2)
{
    return stu1.getage()>stu2.getage()?stu1:stu2;
}

负面结果展示：
在这里插入图片描述
优化后结果展示：
在这里插入图片描述
总结：

  1. 使用引用来避免过多的没有意义的拷贝构造。
  2. 为了提代函数执行的高效性，推荐使用引用做为函数的参数，在适合的情况下（如果这个函数需要返回一个对象），那么也推荐使用引用。

3.4 C++中深拷贝和浅拷贝的区别

浅拷贝：
如果类中没有显性的定义拷贝构造函数，编译器会默认提供一个拷贝构造函数，这个默认提供的拷贝构造函数，只完成成员之间一对一的简单赋值，如果类中没有指针，使用这个默认的拷贝构造函数，是没有问题的。
深拷贝：
如果类中有指针成员，并且使用浅拷贝时，指针成员也会只做简单的赋值，相当于两个对象的指针成员指向的是同一块空间，调用析构函数释放时，就会出现 double free 的问题。所以需要在类中显性给定拷贝构造函数，并给新对象的指针成员重新分配空间，再将旧对象指针成员指向的空间里的数据复制一份过来。
图例：
在这里插入图片描述

四、匿名对象

没有名字但是有地址的

匿名对象产生的情况：

  1. 以值的方式给函数传参；
  2. 类型转换；
  3. 函数需要返回一个对象时；

使用匿名对象给对象赋值方式

类名 s=类名("小红",16);
/*在执行此代码时，利用构造函数生成了一个匿名类对象；然后将此匿名变成了s这个实例对象*/
类名();
/*在执行此代码时，利用无参构造函数生成了一个匿名类对象；执行完此行代码，
因为外部没有接此匿名对象的变量，此匿名又被析构了*/

匿名对象的生命周期
说明：

  1. 在执行类名( )时，生成了一个匿名对象，执行完后，此匿名对象就此消失。这就是匿名对象的生命周期。

  2. 在执行类名 s=类名(“小红”,16);时，首先生成了一个匿名对象，因为外部有s对象在等待被实例化，然后将此匿名对象变为了s对象，其生命周期就变成了s对象的生命周期。

总结：
如果生成的匿名对象在外部有对象等待被其实例化，此匿名对象的生命周期就变成了外部对象的生命周期；如果生成的匿名对象在外面没有对象等待被其实例化，此匿名对象将会生成之后，立马被析构。

代码示例：

#include <iostream>
using namespace std;

class Student{
private:
    string name;
    int age;
public:
    Student()
    {
        cout<<"无参构造函数"<<endl;
    }
    Student(string n, int a):name(n),age(a)
    {
        cout<<"有参构造函数"<<endl;
    }
    void show()
    {
        cout<<"姓名"<< name <<" 年龄"<< age << endl;
    }
    ~Student()
    {
        cout<<"析构函数"<<endl;
    }
};
void func(Student x)
{
    x.show();
}
int main(){
    Student();//匿名对象在外面没有对象等待被其实例化，此匿名对象将会生成之后，立马被析构。
    cout<<"-------------------"<<endl;
    Student s1("小明", 18);//有参构造
    s1.show();
    //使用匿名对象给s2赋值
    Student s2=Student("小红",16);
    cout<<"-------------------"<<endl;
    //匿名对象一般多用于类数组的初始化
    Student arr[5]={Student("a",10),Student("b",20)};
    cout<<"-------------------"<<endl;
    //或者用于给函数传参
    func(Student("张三",35));
    cout<<"-------------------"<<endl;
    return 0;
}

结果展示：
在这里插入图片描述

总结：
匿名对象一般多用于类数组的初始化，或者用于给函数传参的。

夜猫徐
关注
  • 40
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 61
    评论
专栏目录
pandas实现将矩阵导出到excel+对矩阵进行连接，参考博客<猿创征文｜pandas实现将矩阵导出到excel+对矩阵进行>
09-02
博客链接：...
征文｜杨文斌：终端安全之线段理论.pdf
09-18
在本篇文章中，杨文斌提出了一个创新性的理论——线段理论，用于阐述终端安全的重要性，并结合实际场景提出了相应的安全防护措施。 ### 终端安全的理论基础 首先，杨文斌通过数学中的线段概念引出终端安全的线段...
C++学习day4
m0_69894626的博客
10-10 504
1.非常对象可以调用常成员函数，也可以调用非常成员函数，优先调用非常成员函数。2.常对象只能调用常成员函数，如果没有常成员函数，则报错。
C++中常对象、常成员函数、常成员变量
隋森的博客
02-14 2871
用const修饰的类对象叫做常对象， 用const修饰的成员函数叫常成员函数， 用const修饰的成员变量叫常成员变量， 常对象： 型如：      const  &lt;类名&gt;  &lt;对象名&gt;      &lt;类名&gt;  const  &lt;对象名&gt; 说明： 1.常对象内的成员变量值不可修改，所以一定要在定义对象时初始化。 2.常对象只可以调用常成...
再读c++
qq_21515253的博客
05-26 376
再论c++ 趁着最近一周论文改论文的空隙，读了一下*thinking in c++*这本经典书的第一卷，主要对c++中的各种基本概念有了新的认识，在这里就总结下相关的重难点 一、数据抽象 对象：变量/一块存储区 数据+对数据的操作 封装：数据+函数 抽象数据类型/用户定义类型 允许重声明函数，但不允许重声明结构 头文件中不放任何指令 二、隐藏实现 1、访问控制：private/public/protected 2、友元：显式得不使用当前结构成员函数访问当前结构数据（可以访问私有实现、没有this） 友元函数
关于常成员函数对非常成员函数的调用问题
JTR502的博客
05-14 4950
常成员函数不能调用非常成员函数：比如：#include&lt;iostream&gt; using namespace std; class A { const void print(){cout&lt;&lt;fun();} }; int fun() { return 2; } int main() { A.a; a.print(); return 0; }程序报错无法运行...
常成员函数只能调用常成员函数 常对象智能调用常成员函数
lujiandong1的专栏
12-04 5314
class A { public:  void print()const{ cout void test() { print();} void test1() const {print();}   }; int main(int argc, char* argv[]) {  A a; a.print(); a.test(); a.test1();    return
征文｜陈欣炜：终端安全的一点思考——从机场的终端管控说起.pdf
09-18
终端安全是信息安全领域的重要组成部分，它关注的是保护企业内部网络中的终端设备（如计算机、移动设备和工控设备）免受安全威胁的侵害。陈欣炜在其文章《征文｜陈欣炜：终端安全的一点思考——从机场的终端管控说起...
征文｜杨文斌：​零信任之个人理解与实践.pdf
09-18
征文｜杨文斌：​零信任之个人理解与实践 威胁情报 渗透测试 安全运维 安全威胁 安全研究
征文｜李琪志：终端安全实践.pdf
09-18
【李琪志的终端安全实践】探讨了企业在面临日益严峻的网络安全挑战时，如何有效管理和保护终端设备。终端，特别是办公计算机，不仅是企业日常运作的关键工具，也是黑客攻击的主要目标。文章作者李琪志，任职于CVTE，...
常对象 常成员函数 的关系
zhuzongwei1988的专栏
04-14 520
#ifndef CHAP_7_H#define CHAP_7_H#include "iostream"using namespace std;class A{public: A(); void test(); void const_test(); void const_test() const;private: int x; const int y;};A::A():y(10),x(20){ co
非常对象访问常成员函数，导致内部this指针无法访问非常成员函数
梦想博客
10-20 2479
非常对象访问常成员函数，导致内部this指针无法访问非常成员函数,引发如下异常： rror C2662: “LinkedList::showElement”: 不能将“this”指针从“const LinkedList”转换为“LinkedList &”  实例如下： class LinkedList { private: public: void showElem
C++常对象，常变量，常成员函数详解（含添加内容）
热门推荐
E_ROAD_BY_U的博客
08-15 1万+
·        用const修饰的声明数据成员称为常数据成员 ·        用const修饰的声明成员函数称为常成员函数 ·        用const修饰的定义对象称为常对象 变量或对象被const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。 （一）用const修饰的声明数据成员称为常数据成员     有两种声明形式： const int  cctw
常引用，常对象，常成员函数，常数据成员~
qq_37385726的博客
04-29 3052
①常引用 形式—— const 类型 &对象名或变量名 ②常对象 形式——const 类名 对象名 1.常对象的数据成员不能被修改了，在定义的时候应该对其进行初始化 2.常对象不能够调用普通成员函数——因为普通成员函数可能会修改对象的数据类型，这是不安全的。 3.常对象可以调用静态成员函数，常成员函数，其实也可以调友元函数  （但是这里不对每一个具体展开了，就只是为了更加明白常对象是不
简单总结 常（常量/const）成员函数 and 常对象的使用
weixin_44980842的博客
09-16 1403
一、常成员函数 在函数定义式()后 + const 比如： class Rational { public: //非常成员函数 void func() { cout << "func 的 调用" << endl; }; //常成员函数 void func2()const { cout << "func2 const的 调用" << endl; }; //有参构造 Rational(double d):m_d...
C++匿名函数lamba简介
yao_tao11的博客
08-18 661
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
C++(11)类语法分析(2)
Once_day的回忆
08-17 1215
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
C语言：文件（写入，读取）
最新发布
2301_80311224的博客
08-21 483
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
C语言——函数递归
2406_83392683的博客
08-18 385
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
共建网络安全，共享网络文明——中行参与国家网络安全宣传周
此外，中行还组织了一系列内部宣传活动，包括播放网络安全短片、发放知识手册、举办征文活动和信息安全讲座等，进一步强化员工和客户的网络安全知识。 第二个例子是某学校响应国家网络安全宣传周的号召，开展了以...
评论 61
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夜猫徐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值