第三节-类与对象(3)

于 2024-09-29 16:33:45 发布
阅读量558 收藏 4
点赞数 9
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83603768/article/details/142638001
版权

1. 运算符重载基本概念


1.1 运算符重载的基本概念


运算符重载允许我们为类对象自定义运算符的行为，这样当我们对类对象使用这些运算符时，它们会按照我们定义的方式执行。如果没有定义对应的运算符重载，编译器将会报错，因为它不知道如何处理这些运算符。

运算符重载的定义：运算符重载是一个特殊的函数，名字是operator加上要重载的运算符。
参数数量：重载函数的参数数量取决于运算符的类型。一元运算符有一个参数，二元运算符有两个参数。
示例：重载==运算符

#include<iostream>
using namespace std;

class Number {
public:
    Number(int value = 0) : _value(value) {}

    // 重载==运算符用于比较两个Number对象是否相等
    bool operator==(const Number& n) const
    {
        return _value == n._value;
    }

private:
    int _value;
};

int main()
{
    Number n1(10);
    Number n2(10);

    if (n1 == n2) {
        cout << "两个数相等。" << endl;
    } else {
        cout << "两个数不相等。" << endl;
    }

    return 0;
}

解释：operator==：这个重载允许我们直接使用==来比较两个Number对象是否相等，而不需要手动检查它们的内部值。


1.2 重载运算符的规则


函数的名字：重载的函数名称必须是operator加上运算符，例如operator+、operator==。
参数和返回类型：重载的运算符函数需要根据需要设置参数和返回类型。对于二元运算符，左侧对象传给第一个参数，右侧对象传给第二个参数。
示例：重载+运算符

#include<iostream>
using namespace std;

class Number {
public:
    Number(int value = 0) : _value(value) {}

    // 重载+运算符，用于两个Number对象相加
    Number operator+(const Number& n) const
    {
        return Number(_value + n._value);
    }

    void Print() const
    {
        cout << "Value: " << _value << endl;
    }

private:
    int _value;
};

int main()
{
    Number n1(10);
    Number n2(20);

    Number n3 = n1 + n2; // 使用重载的+运算符
    n3.Print(); // 输出: Value: 30

    return 0;
}

解释：

operator+：这个运算符重载允许我们使用+运算符来相加两个Number对象，并返回一个新的Number对象。


2.3 成员函数重载运算符


如上面的例子，当运算符重载定义为类的成员函数时，第一个运算对象会隐式地传递给this指针，因此成员函数的参数数量比操作数少一个。

示例：重载-运算符

#include<iostream>
using namespace std;

class Number {
public:
    Number(int value = 0) : _value(value) {}

    // 重载-运算符，用于两个Number对象相减
    Number operator-(const Number& n) const
    {
        return Number(_value - n._value);
    }

    void Print() const
    {
        cout << "Value: " << _value << endl;
    }

private:
    int _value;
};

int main()
{
    Number n1(20);
    Number n2(10);

    Number n3 = n1 - n2; // 使用重载的-运算符
    n3.Print(); // 输出: Value: 10

    return 0;
}

解释：

operator-：这个重载允许我们使用-运算符来减去两个Number对象的值，并返回一个新的Number对象。


2.4 运算符重载的优先级与结合性


虽然我们可以改变运算符的行为，但其优先级和结合性与内置类型运算符保持一致。这意味着我们不能通过重载运算符来改变它们的运算顺序。

示例：重载*运算符

#include<iostream>
using namespace std;

class Number {
public:
    Number(int value = 0) : _value(value) {}

    // 重载*运算符，用于两个Number对象相乘
    Number operator*(const Number& n) const
    {
        return Number(_value * n._value);
    }

    void Print() const
    {
        cout << "Value: " << _value << endl;
    }

private:
    int _value;
};

int main()
{
    Number n1(5);
    Number n2(4);

    Number n3 = n1 * n2; // 使用重载的*运算符
    n3.Print(); // 输出: Value: 20

    return 0;
}

解释：

operator*：这个重载允许我们使用*运算符来相乘两个Number对象的值，并返回一个新的Number对象，其优先级还是高于重载后的+运算符。

2.5 运算符重载中的限制与特殊情况


2.5.1 不能创建新的操作符


在C++中，虽然可以重载大多数运算符，但不能创建新的操作符。也就是说，我们不能使用C++语法中没有的符号来创建新的运算符。例如，operator@是非法的，因为@符号不是C++中的有效运算符。

解释：

只能重载C++已有的运算符，如+, -, *, /, ==等。不能创建诸如operator@这样的运算符，因为@不属于C++的运算符集合。

2.5.2 无法重载的运算符


在C++中，有五个运算符是不能重载的，这些运算符的行为在语言中是固定的，不能改变。

这些运算符包括：

.（成员访问运算符）
.*（成员指针访问运算符）见以下补充
::（作用域解析运算符）
sizeof（大小计算运算符）
?:（三元条件运算符）
解释：

这些运算符的行为在C++中是固定的，无法通过重载改变它们的语义或使用方式。
示例：尝试重载不能重载的运算符（会报错）

#include<iostream>
using namespace std;

class Number {
public:
    Number(int value = 0) : _value(value) {}

    // 错误：不能重载sizeof运算符
    int operator sizeof() const
    {
        return _value;
    }

private:
    int _value;
};

int main()
{
    Number n1(10);

    // int size = sizeof(n1); // 错误：无法重载sizeof运算符

    return 0;
}

结果：

编译器会报错，因为sizeof是一个固定的运算符，无法通过重载改变其行为。

2.5.3 前置和后置递增运算符的重载


在C++中，递增运算符++可以有两种形式：前置递增和后置递增。它们的功能类似，但实现方式不同。

前置递增：先递增，然后返回递增后的值。
后置递增：先返回当前值，然后递增。
为了区分前置和后置递增运算符，C++规定在重载后置递增运算符时，必须增加一个int参数。这只是一个区分符，并没有实际用途。

示例：重载前置和后置递增运算符

前置直接操作对象，传引用返回，而后置返回副本，用传值返回

#include<iostream>
using namespace std;

class Number {
public:
    Number(int value = 0) : _value(value) {}

    // 重载前置++
    Number& operator++()
    {
        ++_value;
        return *this;
    }

    // 重载后置++
    Number operator++(int)
    {
        Number tmp = *this; // 保存当前值
        ++_value;           // 递增
        return tmp;         // 返回原始值
    }

    void Print() const
    {
        cout << "Value: " << _value << endl;
    }

private:
    int _value;
};

int main()
{
    Number n1(5);

    ++n1; // 前置++
    n1.Print(); // 输出: Value: 6

    n1++; // 后置++
    n1.Print(); // 输出: Value: 7

    return 0;
}

解释：operator++()：这是前置递增的实现。先递增，然后返回递增后的对象自身。
operator++(int)：这是后置递增的实现。先保存当前对象的副本，然后递增，并返回副本。

结果：前置递增直接修改并返回对象自身，而后置递增返回递增前的副本，之后再进行递增。
这里我们直接使用的普通++类型来实现+1操作，在之后实现了+=运算符重载后可以实现复用，这在最后类和对象的实践篇：日期类的实现会讲到

2 赋值运算符重载


赋值运算符重载是一个特殊的运算符重载，用于将一个对象的状态复制到另一个已经存在的对象中。需要注意的是，赋值运算符重载与拷贝构造函数是不同的，拷贝构造用于初始化一个新对象，而赋值运算符则用于给已经存在的对象赋值。

2.1 赋值运算符重载必须定义为成员函数


赋值运算符重载是C++的一个特殊运算符重载，必须作为类的成员函数来定义。这是因为赋值运算符总是需要操作当前对象(this指针)，因此它不能作为全局函数来实现。

示例：定义赋值运算符重载

#include<iostream>
using namespace std;

class MyClass {
public:
    MyClass(int value = 0) : _value(value) {}

    // 赋值运算符重载，参数是const类型的引用
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {  // 防止自我赋值
            _value = other._value;
        }
        return *this;  // 返回当前对象的引用，以支持链式赋值
    }

    void Print() const {
        cout << "Value: " << _value << endl;
    }

private:
    int _value;
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);

    obj2 = obj1;  // 调用赋值运算符重载

    obj2.Print(); // 输出: Value: 10

    return 0;
}

解释：

operator=：这是赋值运算符的重载函数。this指针指向当前对象，other是被赋值的对象。
if (this != &other)：检查当前对象是否与传入对象是同一个对象，如果是同一个对象，则跳过赋值操作，以避免自我赋值引起的问题。
return *this;：返回当前对象的引用，这允许连续的赋值操作，例如a = b = c;。


2.2 有返回值，建议写成当前类类型的引用

赋值运算符重载函数通常返回当前对象的引用，这样可以安全支持链式赋值操作，即多个对象之间连续赋值的语句。

示例：支持链式赋值

#include<iostream>
using namespace std;

class MyClass {
public:
    MyClass(int value = 0) : _value(value) {}

    // 赋值运算符重载，返回当前对象的引用
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            _value = other._value;
        }
        return *this;
    }

    void Print() const {
        cout << "Value: " << _value << endl;
    }

private:
    int _value;
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);
    MyClass obj3(30);

    obj1 = obj2 = obj3;  // 链式赋值

    obj1.Print(); // 输出: Value: 30
    obj2.Print(); // 输出: Value: 30

    return 0;
}

解释：在链式赋值中，obj2 = obj3 会首先执行，operator= 返回 obj2 的引用，然后 obj1 = obj2 执行，这样 obj1 最终也得到了 obj3 的值。


2.3 编译器自动生成的默认赋值运算符


如果我们没有显式定义赋值运算符重载，编译器会自动生成一个默认的赋值运算符。

这个默认的赋值运算符执行的是浅拷贝操作：对于内置类型成员变量，逐个字节地复制值；对于自定义类型成员变量，则调用它们的赋值运算符重载。

示例：使用编译器生成的默认赋值运算符

#include<iostream>
using namespace std;

class MyClass {
public:
    MyClass(int value = 0) : _value(value) {}

    // 未显式定义赋值运算符重载，编译器会自动生成
    void Print() const {
        cout << "Value: " << _value << endl;
    }

private:
    int _value;
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);

    obj2 = obj1;  // 使用编译器生成的默认赋值运算符

    obj2.Print(); // 输出: Value: 10

    return 0;
}

解释：在这个例子中，编译器生成了一个默认的赋值运算符，它对内置类型的成员变量执行浅拷贝操作。


2.4 显式实现赋值运算符重载的必要性


在一些情况下，例如类中包含指针成员或其他动态资源，浅拷贝可能会导致问题。这时，我们需要显式实现赋值运算符重载来进行深拷贝，以确保对象的独立性。

示例：显式实现赋值运算符进行深拷贝

#include<iostream>
using namespace std;

class MyClass {
public:
    MyClass(int value = 0) : _value(new int(value)) {}

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        _value = new int(*other._value);
    }

    // 赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete _value; // 删除旧的动态内存
            _value = new int(*other._value); // 分配新的动态内存并复制值
        }
        return *this;
    }

    ~MyClass() {
        delete _value; // 析构函数中释放动态内存
    }

    void Print() const {
        cout << "Value: " << *_value << endl;
    }

private:
    int* _value; // 指针类型成员变量
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);

    obj2 = obj1;  // 使用自定义的赋值运算符进行深拷贝

    obj1.Print(); // 输出: Value: 10
    obj2.Print(); // 输出: Value: 10

    return 0;
}

解释：在这个例子中，MyClass 类中包含一个指针成员变量 _value，我们需要自定义赋值运算符以确保进行深拷贝，即在赋值时为 _value 分配新的内存，并将值复制到新分配的内存中。

2.5 赋值运算符与析构函数的关系


如果一个类显式定义了析构函数来释放动态资源，那么它通常也需要显式定义赋值运算符重载，以避免浅拷贝带来的资源管理问题。

示例：显式实现析构函数和赋值运算符重载

#include<iostream>
using namespace std;

class MyClass {
public:
    MyClass(int value = 0) : _value(new int(value)) {}

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        _value = new int(*other._value);
    }

    // 赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete _value;
            _value = new int(*other._value);
        }
        return *this;
    }

    // 析构函数
    ~MyClass() {
        delete _value;
    }

    void Print() const {
        cout << "Value: " << *_value << endl;
    }

private:
    int* _value;
};

int main() {
    MyClass obj1(10);
    MyClass obj2(20);

    obj2 = obj1;  // 使用自定义的赋值运算符进行深拷贝

    obj1.Print(); // 输出: Value: 10
    obj2.Print(); // 输出: Value: 10

    return 0;
}

解释：

MyClass 包含一个指针成员变量 _value，我们通过显式实现赋值运算符和析构函数来管理动态内存，确保不会因为浅拷贝导致资源泄漏或多次释放同一块内存。
总结
赋值运算符重载在管理动态资源、确保对象独立性以及支持链式赋值时非常有用。通过理解赋值运算符的特性和如何正确实现它，我们可以编写更健壮的C++程序，避免浅拷贝带来的问题。

3. 取地址运算符重载

在C++中，取地址运算符&用于获取对象的内存地址。在大多数情况下，编译器自动生成的取地址运算符重载已经足够使用。然而，在某些特殊场景下，我们可能希望控制或限制对象地址的获取方式，这时候我们就可以手动重载取地址运算符。

3.1 const成员函数

const成员函数是指用const修饰的成员函数。它主要用于确保成员函数不会修改类的成员变量，从而保证函数的只读特性。

用法：将const修饰符放在成员函数的参数列表之后。
效果：const实际修饰的是成员函数中隐含的this指针，表示在该成员函数中不能对类的任何成员进行修改。
示例代码：const成员函数

#include<iostream>
using namespace std;

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1) 
        : _year(year), _month(month), _day(day) {}

    // const成员函数，表示不会修改类成员变量
    void Print() const {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() {
    // 非const对象可以调用const成员函数
    Date d1(2024, 7, 5);
    d1.Print();

    // const对象也可以调用const成员函数
    const Date d2(2024, 8, 5);
    d2.Print();

    return 0;
}

解释：

void Print() const：const修饰了Print函数，表示它不会修改Date类的成员变量。this指针的类型在这个函数中变为const Date* const，意味着它指向的对象及指针本身都不能被修改。
权限的缩小：const对象只能调用const成员函数，而非const对象可以调用任意成员函数，这体现了一种权限的缩小。


3.2 取地址运算符重载

取地址运算符&通常用于获取对象的地址。通过重载该运算符，可以自定义获取对象地址的方式，甚至可以禁止获取地址或返回一个伪造的地址。

普通取地址运算符重载
普通取地址运算符用于非const对象，重载后可以控制返回对象的地址。

示例代码：普通取地址运算符重载

#include<iostream>
using namespace std;

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1) 
        : _year(year), _month(month), _day(day) {}

    // 重载普通取地址运算符
    Date* operator&() {
        // return this;  // 返回对象的真实地址
        return nullptr;  // 返回空指针，伪装地址
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d1(2024, 7, 5);
    Date* p1 = &d1;  // 使用重载的取地址运算符

    if (p1 == nullptr) {
        cout << "未获取到真实地址" << endl;
    } else {
        cout << "对象的地址为: " << p1 << endl;
    }

    return 0;
}


解释：

Date* operator&()：这是普通的取地址运算符重载。可以根据需求决定是否返回对象的真实地址，也可以返回nullptr或其他伪造地址，以达到某些特定需求（如禁止获取对象地址）的目的。
const取地址运算符重载
const取地址运算符用于const对象，重载后可以控制如何返回const对象的地址。

示例代码：const取地址运算符重载

#include<iostream>
using namespace std;

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1) 
        : _year(year), _month(month), _day(day) {}

    // 重载const取地址运算符
    const Date* operator&() const {
        // return this;  // 返回对象的真实地址
        return nullptr;  // 返回空指针，伪装地址
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() {
    const Date d1(2024, 8, 5);
    const Date* p1 = &d1;  // 使用重载的取地址运算符

    if (p1 == nullptr) {
        cout << "未获取到真实地址" << endl;
    } else {
        cout << "对象的地址为: " << p1 << endl;
    }

    return 0;
}

解释：

const Date* operator&() const：这是const取地址运算符重载。它同样可以控制是否返回const对象的真实地址或者伪装地址。
总结
默认行为：在大多数情况下，编译器自动生成的取地址运算符已经足够使用，不需要手动重载。
特殊需求：在一些特殊场景（如禁止获取对象地址）下，可以通过重载取地址运算符来自定义行为。
const修饰：通过const修饰符可以控制成员函数的只读特性，确保在函数中不修改类成员变量。同时，const取地址运算符重载可以用于const对象，确保其地址获取方式受到控制。
写在最后
运算符重载使C++类对象能像基本数据类型一样操作，赋予类更直观的行为。通过重载 +、- 等运算符，我们可以实现对象间的运算和比较。赋值运算符尤其重要，确保对象在涉及动态资源时安全地复制。const 成员函数则提供了数据保护，避免意外修改。总的来说，运算符重载让代码更加简洁优雅，增强了程序的灵活性。

绵绵细雨中的乡音
关注
类和对象实战 —— 日期类的实现
Edison's 小宇宙
10-24 1万+
日期类的实现
推选文档第一节-物理系统的实施-第二节-程序设计-第三节-软件开发工PPT.ppt
11-13
**第三节 软件开发工具** 这部分可能涉及用于编码、调试、版本控制和项目管理的各种工具，如集成开发环境（IDE）、版本控制系统（如Git）、自动化构建工具（如Maven）和项目管理软件（如JIRA）。这些工具能提高开发...
Java--类和对象第三节--继承
2301_80251684的博客
05-17 1329
是面向对象语言的三大特征之一说到继承，网文爽剧里面经常会写到继承老爷子的百亿家产，刨根到底分析，是不是继承后，你就可以使用老爷的所拥有的东西了？在Java中，这种现象就叫做继承，老爷子叫做基类也叫做父类和超类，而你我的朋友叫做派生类也叫做子类。
头歌 C# 专题四 类与对象第5节
qq_53679247的博客
01-31 2212
第5关：static静态对象 任务要求 评论28 任务描述 相关知识 static 静态变量的声明和使用 一个实例 特别实例 编程要求 测试说明 任务描述 大学校园内有各种各样的社团，一般每个社团都会不定期举办一些大型活动，活动的时间和地点可能会有所差异。例如某摄影社团2018年上半年活动表： 次数统计 时间 地点 1 2018-03-22 北京大学 2 2018-05-01 中国人民大学 3 2018-06-01 清华大学 本关任务：根据编程要...
第三章Web开发篇——第3节-JavaScript快速入门
gis_witch的博客
03-21 1383
1. 什么是JavaScript JavaScript是一种编程语言 变量 函数 数组/对象 事件
《Java程序设计》实验报告——Java的对象与类
无限迭代中......
10-07 7152
浙江理工大学 《Java程序设计》 实验报告 20 19～20 20学年第 1学期 学 院 信息学院 班 级 计算机科学与技术18(3) 姓 名 申屠志刚 学 号 2018329621200 ...
（软件工程复习核心重点）第八章面向对象方法学-第三节：面向对象建模之对象模型
快乐江湖的博客
01-19 1万+
文章目录一：概念（1）定义（2）工具二：类图的基本符号（1）定义类A：表示B：命名规则（2）定义属性（3）定义服务三：表示关系的符号（1）关联A：定义B：关联的角色C：普通关联①：定义②：表示D：限定关联①：定义②：表示③：意义E：关联类①：定义②：表示（2）聚集（它是关联的特例）A：共享聚集B：组合聚集（3）泛化（本质就是继承）A：普通泛化①：抽象类②：具体类B：受限泛化①：定义②：约束（4）依赖和细化A：依赖关系B：细化关系 一：概念 （1）定义 对象模型表示静态的、结构化的系统的数据性质。它是对模拟客
c++类和对象
includeevey的博客
10-06 7756
全文将讲解《类和对象》，文章比较长，请慢慢观看！
【Python学习教程】Python类和对象
qq_41854911的博客
01-26 9788
转载于http://c.biancheng.net/python/ Python 语言在设计之初，就定位为一门面向对象的编程语言，“Python 中一切皆对象”就是对 Python 这门编程语言的完美诠释。 类和对象是 Python 的重要特征，相比其它面向对象语言，Python 很容易就可以创建出一个类和对象。同时，Python 也支持面向对象的三大特征：封装、继承和多态。 本章不仅会教你掌握 Python 类和对象的基本语法，还可以带你深入底层，了解 Python 面向对象的实现原理。 什么是面向对象，
LabVIEW目标对象分类识别（理论篇—5）
热门推荐
不脱发的程序猿
08-01 3万+
目标对象分类是机器视觉领域非常活跃的研究方向，在工业领域有极其广泛的应用，例如对生产线上的零件按形状、颜色等特征分拣，统计具有某种特征的零件，或通过辨别目标的类别进行质量检测等。
（软件工程复习核心重点）第九章面向对象分析-第二节：面向对象分析之建立对象模型
快乐江湖的博客
01-24 4907
文章目录一： 基本概念（1）对象模型（2）先建立对象模型的原因（3）信息来源（4）典型的建模步骤二：确定类与对象 一： 基本概念 （1）对象模型 面向对象分析的首要工作就是建立问题域的对象模型。对象模型表示静态的、结构化的系统的数据性质。它是对模拟客观世界实体的对象以及对象彼此间的关系的映射，描述了系统的静态结构。对象模型为建立动态模型和功能模型，提供了实质性的框架 （2）先建立对象模型的原因 静态数据结构对应用细节依赖较少，比较容易确定 当用户的需求变化时，静态数据结构相对来说比较稳定 （3）信息来源
5-3面向对象的功能实现.docx
11-08
- 使用广东教育出版社的信息技术（选修一）《算法与程序设计》第五章第三节内容作为核心框架。 - 结合上海科教版普通高中信息技术课程实验教材《算法与程序设计》的相关章节，以补充和完善教学内容。 - 采取讲解...
13第三节安全科学的定义、性质、对象及分类.pptx
10-10
13第三节安全科学的定义、性质、对象及分类.pptx
第十三节–对象串行化
12-17
 | = PHP5研究中心： http://blog.csdn.net/haohappy2004 +——————————————————————————-+ */ 第十三节–对象串行化 串行化可以把变量包括对象,转化成连续bytes数据. 你可以将
深度学习入门-Python语言学习-13面向对象基础-入门学习
06-16
封装是面向对象编程的第三个基本概念之一。它将对象的属性和方法封装在一起，以保护对象的内部实现。例如： ``` class Washer(): def __init__(self): self.width = 500 self.height = 800 def wash(self): ...
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 994
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1009
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
【ARM 嵌入式 C 入门及渐进26 -- 内敛函数和宏定义的区别】
最新发布
CodingCos的博客
09-25 884
在 C 语言中，内联函数和宏定义都可以用来减少函数调用的开销和提高代码执行效率，但它们在许多方面存在显著区别。内联函数使用inline关键字定义。宏定义使用#define预处理指令。无类型检查：宏是文本替换，没有类型检查，可能导致类型错误。调试困难：宏替换在预处理阶段完成，难以在调试器中跟踪宏的行为。全局作用域：宏在定义后全局有效，可能引起命名冲突和作用域污染。维护复杂：宏替换简单但容易出错，逻辑复杂时难以维护。性能优化：宏是简单的文本替换，不涉及编译器优化。return 0;
pyqt瀑布流布局
weixin_54217201的博客
09-21 482
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

绵绵细雨中的乡音

感谢您陌生人对我求学之路的支持

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

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

打赏作者

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

抵扣说明：

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

余额充值