C++：日期类实现与运算符重载

最新推荐文章于 2026-06-26 18:45:00 发布
原创 最新推荐文章于 2026-06-26 18:45:00 发布 · 467 阅读 · 19 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c++ #开发语言 #类和对象 #日期类

目录

1. 日期类设计思路

2. 核心功能

2.1 构造与校验

2.2 日期运算

2.3 日期自增自减

2.4 各类比较运算符

2.5 输入输出流

3. 代码实现

1. 日期类设计思路

日期是一个看似简单但细节很多的类型。月有长短、闰年二月特殊、跨年进位……这些规则让日期类成为练习C++类设计的绝佳案例。

本文实现了一个完整的class Date，支持：

  • 日期合法性校验

  • 日期 ± 天数

  • 两个日期相减（得到天数差）

  • 前置/后置自增自减

  • 全部比较运算符

  • 流输入输出

2. 核心内容与功能

该日期类采用年、月、日三个成员变量实现。

成员变量：

class Date
{
private:
    int _year;
    int _month;
    int _day;
};

2.1 构造、析构与校验

默认构造函数：由于成员变量中不涉及资源空间的开辟，因此我们可以选择不写默认构造函数。但由于编译器对于内置类型的变量初始化是未定义的，为了严谨起见，这里手动实现一个全缺省的默认构造函数：

// 全缺省的构造函数
// 声明
Date(int year = 1900, int month = 1, int day = 1);

// 定义
Date::Date(int year, int month, int day)
{
    _year = year;
    _month = month;
    _day = day;

    if(!CheckDate())
    {
        cout << "输入的日期非法！" << endl;
    }
}

注意：声明中需要具体写缺省值，定义中不能重复写，仅需写对应类型和形参。

拷贝构造函数：可以选择不写，还是由于不涉及资源空间开辟的原因。但是以练习为目的的话还是推荐自己手动实现一下的：

// 拷贝构造函数d2(d1)
// 声明
Date(const Date& d);

// 定义
Date::Date(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}

说一下拷贝函数内部什么时候需要确认是否为自拷贝：

如果涉及资源空间的开辟，一定要检验拷贝不是自拷贝。

因为拷贝涉及对原有空间释放和获取拷贝源头数据的操作，自拷贝会导致释放了自己的空间后又试图找到并拷贝这个空间，最终导致程序崩溃。

析构函数：可以选择不写，依旧是因为不涉及资源空间的开辟：

// 析构函数
// 声明
~Date();

// 定义
Date::~Date()
{
    _year = 0;
    _month = 0;
    _day = 0;
}

校验日期的合法性：

如何判断这个日期是否合法？

方便起见，我们抛开年份不谈（笔者不太清楚历史TvT），直接对月份和日期进行校验。

通过月份判断天数是否合法，容易想到可以先用数组实现一个获取天数的函数：把月份作为下标，通过访问下标获取天数，然后可以据此判断日期的合法性。

对于获取天数的函数，声明和定义都放在类内实现，默认是inline函数。这个函数经常使用且代码长度较短，符合inline函数标准。另外，用static把数组放在静态区可以减少不必要的数组创建和销毁，提高效率。

// 获取某年某月的天数
int GetMonthDay(int year, int month) const
{
    assert(month > 0 && month < 13);

    static int MonthDay[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    if(month == 2 && ((year%4==0 && year%100!=0) ||(year%400==0)))
    {
        return 29;
    }
    return MonthDay[month];
}
// 判断日期合法
// 声明
bool CheckDate() const;

// 定义
bool Date::CheckDate() const
{
    if(_month < 1 || _month > 12)
    {
        return false;
    }

    if(_day < 1 || _day > GetMonthDay(_year, _month))
    {
        return false;
    }

    return true;
}

2.2 日期运算

在计算日期前，我们需要对以下运算符进行重载：

  •  + ：日期加天数，返回新的日期，原日期不改变
  •  -  ：日期减天数，返回新的日期，原日期不改变；日期减日期，返回相差的天数
  • += ：日期加天数，返回新的原日期
  • - = ：日期减天数，返回新的原日期

方便的是，只要实现了+=和-=，那么+和-可以复用这些操作符，大大减少了代码量。

计算方面，可以运用上之前获取天数的方法，通过类似加法进位，减法退位的方法计算日期。

注意：如果涉及原日期的修改，需要传引用返回；不需要修改，则需要传值返回。

Q：为什么不是+=和-=复用+和-？

A：因为+和-涉及到类对象的拷贝，会降低效率；而+=和-=是直接对对象的引用进行操作的，不会影响效率。

另外，如果日期是非法的，那么就不能进行运算了。因此在运算前记得检查一下日期的合法性😎

声明：

// 日期+=天数
Date& operator+=(int day);

// 日期-=天数
Date& operator-=(int day);

// 日期+天数
Date operator+(int day);

// 日期-天数
Date operator-(int day);

// 日期-日期 返回天数
int operator-(const Date& d);

定义：

// 日期+=天数
Date& Date::operator += (int day)
{
    if(!CheckDate())
    {
        cout << "日期非法，无法运算！" << endl;
        return *this;
    }

    if(day < 0)
    {
        return *this -= (-day);
    }

    _day += day;
    while(_day > GetMonthDay(_year, _month))
    {
        _day -= GetMonthDay(_year, _month);
        _month++;

        if(_month == 13)
        {
            _year++;
            _month = 1;
        }
    }

    return *this;
}

// 日期-=天数
Date& Date::operator -= (int day)
{
    if(!CheckDate())
    {
        cout << "日期非法，无法运算！" << endl;
        return *this;
    }

    if(day < 0)
    {
        return *this += (-day);
    }

    _day -= day;
    while(_day <= 0)
    {
        _day += GetMonthDay(_year, _month);
        _month--;

        if(_month == 0)
        {
            _year--;
            _month = 12;
        }
    }

    return *this;
}

// 日期+天数
Date Date::operator + (int day)
{
    Date tmp = *this;
    tmp += day;
    return tmp;
}

// 日期-天数
Date Date::operator - (int day)
{
    Date tmp = *this;
    tmp -= day;
    return tmp;
}

// 日期-日期 返回天数
int Date::operator - (const Date& d)
{
    int flag = 1;
    Date big = *this;
    Date small = d;

    if(*this < d)
    {
        big = d;
        small = *this;
        flag = -1;
    }

    int Nday = 0;
    while(small != big)
    {
        small++;
        Nday++;
    }

    return Nday * flag;
}

2.3 日期自增自减

自增自减涉及到前置运算符和后置运算符。由于运算符重载时第一个参数不需要显式传，自增自减又是一元运算符，会导致无法区分前置和后置。

因此C++规定，前置运算符重载时不传参，后置运算符重载需要传一个占位int类型来区分；

同时，由于前置先自增后使用的特性，可以直接传引用返回；后置自增则需要拷贝一次对象，对象自增后返回拷贝值，可以确保在使用后再自增，因此需要传值返回。

自减同理。

上述可见，在使用时更推荐前置自增自减，可以省去拷贝步骤，提高效率😎

// 前置++
Date& Date::operator ++ ()
{
    *this += 1;
    return *this;
}

// 后置++
Date Date::operator ++ (int)
{
    Date tmp = *this;
    *this += 1;
    return tmp;
}
// 前置--
Date& Date::operator -- ()
{
    *this -= 1;
    return *this;
}

// 后置--
Date Date::operator -- (int)
{
    Date tmp = *this;
    *this -= 1;
    return tmp;
}

2.4 各类比较运算符

有了日期运算的经验，我们可以在重载各类比较运算符时进行复用，比如手动实现了>和==的函数逻辑，就可以在>=，<=，<等复用了，省时省力🤩

不过至少要自己实现两个函数，切忌全部复用！否则就会出现你复用我，我复用你的无限递归情况，比如：

这里 >= 和 < 互相复用，就会陷入无限递归了TvT

// >运算符重载
bool Date::operator > (const Date& d)
{
    if(_year > d._year)
    {
        return true;
    }

    if(_year == d._year && _month > d._month)
    {
        return true;
    }

    if(_month == d._month && _day > d._day)
    {
        return true;
    }

    return false;
}

// ==运算符重载
bool Date::operator == (const Date& d)
{
    if(_year == d._year && _month == d._month && _day == d._day)
    {
        return true;
    }

    return false;
}

// >=运算符重载
bool Date::operator >= (const Date& d)
{
    return (!(*this < d));
}

// <运算符重载
bool Date::operator < (const Date& d)
{
    return (!((*this > d) || (*this == d)));
}

// <=运算符重载
bool Date::operator <= (const Date& d)
{
    return (!(*this > d));
}

// !=运算符重载
bool Date::operator != (const Date& d)
{
    return (!(*this == d));
}

2.5 输入输出流

为了方便日期的输入输出，这里还需要对运算符<<和>>进行重载。

但是，如果重载函数放在类内部，而类内部又默认第一个参数是类类型的引用，那么就会出现一个非常诡异的使用方式：

离谱的是，这种反直觉的设计是可以正常运行的，不过由于可读性极差，不支持链式调用等一系列问题，非常不推荐写成这种形式。因此，这里推荐一个更正规的写法：设置为全局函数

把运算符重载函数放在全局声明，并在类内部（位置不限）声明友元函数即可，这下就实现了和普通cin / cout一样的功能了：支持连续输入输出，使用起来和平时一样顺手🤓

//类内部友元函数声明
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
//输入输出（全局声明）
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);
//输入输出（全局）
ostream& operator << (ostream& out, const Date& d)
{
    out << d._year << "年" << d._month << "月" << d._day << "日";
    return out;
}

istream& operator >> (istream& in, Date& d)
{
    cout << "请依次输入年月日：" << endl;
    while(1)
    {
        in >> d._year >> d._month >> d._day;
        if(!d.CheckDate())
        {
            cout << "输入日期" << d << "非法，请重新输入！" << endl;
        }
        else
        {
            break;
        }
    }

    return in;
}

3. 代码实现

以下是所有代码整合：

Date.h文件

#pragma once

#include<iostream>
#include<assert.h>
using namespace std;

class Date
{
    //友元函数声明
    friend ostream& operator<<(ostream& out, const Date& d);
    friend istream& operator>>(istream& in, Date& d);


public:

    // 获取某年某月的天数
    int GetMonthDay(int year, int month) const
    {
        assert(month > 0 && month < 13);

        static int MonthDay[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        if(month == 2 && ((year%4==0 && year%100!=0) ||(year%400==0)))
        {
            return 29;
        }
        return MonthDay[month];
    }

    // 全缺省的构造函数
    Date(int year = 1900, int month = 1, int day = 1);

    // 拷贝构造函数
    // d2(d1)
    Date(const Date& d);

    // 析构函数
    ~Date();

    // 赋值运算符重载
    // d2 = d3 -> d2.operator=(&d2, d3)
    Date& operator=(const Date& d);

    //判断日期合法
    bool CheckDate() const;

    //打印日期
    void Print() const;

    // 日期+=天数
    Date& operator+=(int day);

    // 日期-=天数
    Date& operator-=(int day);

    // 日期+天数
    Date operator+(int day);

    // 日期-天数
    Date operator-(int day);

    // 前置++
    Date& operator++();

    // 后置++
    Date operator++(int);

    // 前置--
    Date& operator--();

    // 后置--
    Date operator--(int);

    // >运算符重载
    bool operator>(const Date& d);

    // ==运算符重载
    bool operator==(const Date& d);

    // >=运算符重载
    bool operator >= (const Date& d);

    // <运算符重载
    bool operator < (const Date& d);

    // <=运算符重载
    bool operator <= (const Date& d);

    // !=运算符重载
    bool operator != (const Date& d);

    // 日期-日期 返回天数
    int operator-(const Date& d);

private:

    int _year;
    int _month;
    int _day;
};

//输入输出（全局）
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

Date.cpp文件

#include"Date.h"

// 全缺省的构造函数(参数只能给在声明中！)
Date::Date(int year, int month, int day)
{
    _year = year;
    _month = month;
    _day = day;

    if(!CheckDate())
    {
        cout << "输入的日期非法！" << endl;
    }
}

// 拷贝构造函数
// d2(d1)
Date::Date(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}

// 析构函数
Date::~Date()
{
    _year = 0;
    _month = 0;
    _day = 0;
}

// 赋值运算符重载(如果开辟了资源需要先释放)
// d2 = d3 -> d2.operator=(&d2, d3)
Date& Date::operator=(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this;
}

//判断日期合法
bool Date::CheckDate() const
{
    if(_month < 1 || _month > 12)
    {
        return false;
    }

    if(_day < 1 || _day > GetMonthDay(_year, _month))
    {
        return false;
    }

    return true;
}

//打印日期
void Date::Print() const
{
    if(!CheckDate())
    {
        cout << "日期非法，无法打印！" << endl;
        return;
    }

    cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

// 日期+=天数
Date& Date::operator += (int day)
{
    if(!CheckDate())
    {
        cout << "日期非法，无法运算！" << endl;
        return *this;
    }

    if(day < 0)
    {
        return *this -= (-day);
    }

    _day += day;
    while(_day > GetMonthDay(_year, _month))
    {
        _day -= GetMonthDay(_year, _month);
        _month++;

        if(_month == 13)
        {
            _year++;
            _month = 1;
        }
    }

    return *this;
}

// 日期-=天数
Date& Date::operator -= (int day)
{
    if(!CheckDate())
    {
        cout << "日期非法，无法运算！" << endl;
        return *this;
    }

    if(day < 0)
    {
        return *this += (-day);
    }

    _day -= day;
    while(_day <= 0)
    {
        _day += GetMonthDay(_year, _month);
        _month--;

        if(_month == 0)
        {
            _year--;
            _month = 12;
        }
    }

    return *this;
}

// 日期+天数
Date Date::operator + (int day)
{
    Date tmp = *this;
    tmp += day;
    return tmp;
}

// 日期-天数
Date Date::operator - (int day)
{
    Date tmp = *this;
    tmp -= day;
    return tmp;
}

// 前置++
Date& Date::operator ++ ()
{
    *this += 1;
    return *this;
}

// 后置++
Date Date::operator ++ (int)
{
    Date tmp = *this;
    *this += 1;
    return tmp;
}

// 前置--
Date& Date::operator -- ()
{
    *this -= 1;
    return *this;
}

// 后置--
Date Date::operator -- (int)
{
    Date tmp = *this;
    *this -= 1;
    return tmp;
}

// >运算符重载
bool Date::operator > (const Date& d)
{
    if(_year > d._year)
    {
        return true;
    }

    if(_year == d._year && _month > d._month)
    {
        return true;
    }

    if(_month == d._month && _day > d._day)
    {
        return true;
    }

    return false;
}

// ==运算符重载
bool Date::operator == (const Date& d)
{
    if(_year == d._year && _month == d._month && _day == d._day)
    {
        return true;
    }

    return false;
}

// >=运算符重载
bool Date::operator >= (const Date& d)
{
    return (!(*this < d));
}

// <运算符重载
bool Date::operator < (const Date& d)
{
    return (!((*this > d) || (*this == d)));
}

// <=运算符重载
bool Date::operator <= (const Date& d)
{
    return (!(*this > d));
}

// !=运算符重载
bool Date::operator != (const Date& d)
{
    return (!(*this == d));
}

// 日期-日期 返回天数
int Date::operator - (const Date& d)
{
    int flag = 1;
    Date big = *this;
    Date small = d;

    if(*this < d)
    {
        big = d;
        small = *this;
        flag = -1;
    }

    int Nday = 0;
    while(small != big)
    {
        small++;
        Nday++;
    }

    return Nday * flag;
}

//输入输出（全局）
ostream& operator << (ostream& out, const Date& d)
{
    out << d._year << "年" << d._month << "月" << d._day << "日";
    return out;
}

istream& operator >> (istream& in, Date& d)
{
    cout << "请依次输入年月日：" << endl;
    while(1)
    {
        in >> d._year >> d._month >> d._day;
        if(!d.CheckDate())
        {
            cout << "输入日期" << d << "非法，请重新输入！" << endl;
        }
        else
        {
            break;
        }
    }

    return in;
}

如果对你有帮助，还请多多支持~[]~(￣▽￣)~*我们下篇博客见

//封面是saki酱🥰

C++：运算符重载以及日期类的实现
qq_56870066的博客
03-19 1002
你能快速知道多少天以前的日期，或者多少天以后的日期吗？
C++入门：运算符重载及日期类的实现
2301_79501467的博客
04-18 1434
提问：拷贝构造中也有“=”的写法，赋值运算符中也有“=”的写法，是不是实现一个就可以了呢？欢迎留言评论区。
深入篇【C++】类与对象：运算符重载详解 -(下)+日期类的实现
Extreme_wei的博客
05-09 1011
深入篇【C++】类与对象：运算符重载详解-(下）+日期类的实现💯干货满满！带你理解更全面的C++！！！
【C++】：拷贝构造函数与赋值运算符重载的实例应用之日期类的实现
CSDN官方认证C/C++研发领域优质创作者 CSDN官方2023年成都赛道Top3 第16届蓝桥杯C/C++软件赛四川赛区二等奖 带你玩转C/C++ 数据结构与算法 Linux系统编程/Linux网络编程 MySQL数据库 软件测试开发
10-26 2737
🔑+=实现的思路就是，实现一个循环，直到天数回到该月的正常天数为止，在循环内部要做的就是进月和进年，让天数不断减去本月天数，直到恢复本月正常天数时，循环结束，返回对象本身即可。🔑-=实现的思路就是，实现一个循环，直到天数变为正数为止，在循环内部要做的就是借月和借年，让天数不断加上上一个月份的天数，直到恢复正数为止，循环结束，返回对象本身。🔑由于日期类的大小比较，均不涉及对自身的改变，对此，我们统一用const来修饰this指针，让其变成const成员函数，减少代码的出错性。🔑前置−−和后置−−重载。
1、C++ 基础知识笔记
qq_54441756的博客
06-25 377
C++基础知识
2026 AI 开发者生存指南（3）：AI 编程工具深度评测——Claude Code vs Cursor vs Copilot vs Cline
smallym1的博客
06-21 754
2026 年主流 AI 编程工具全面对比：Copilot、Cline、Claude Code、Cursor 的能力差异、推荐组合工作流、场景化选型建议和实际效率数据。
ROS2 C++ 运动控制算法保姆级教程
冰冻三尺非一日之寒
06-24 637
本文是ROS2 C++系列第四篇，聚焦于AGV底盘运动控制算法的常见C++实现方式。文章系统性地讲解了底盘控制中关键编程模式： 核心封装结构 class用于封装算法模块（PID控制器、运动学模型） struct管理状态数据（RobotState保存位姿/速度，ChassisParam存储机械参数） enumclass规范控制模式（STOP/MANUAL/AUTO等） 关键标准库工具 std::vector管理动态数据（路径点序列） std::array处理固定尺寸数据（轮速数组） std::clamp实现安
C语言：预处理进阶（宏技巧与GCC优化实战）
x1649545783的博客
06-25 261
本文深入讲解C语言预处理在工程开发中的进阶用法，涵盖标准内置宏、可变参数宏、GCC属性声明、内联函数与编译优化等核心内容。重点介绍了日志调试中常用的__FILE__、__LINE__等内置宏，##__VA_ARGS__解决空参数问题，do{}while(0)规范多行宏编写，以及弱符号、内联函数等性能优化技巧。文章通过实际代码示例演示了工业级日志宏的封装方法，并总结了面试高频考点和常见易错点，帮助开发者提升代码工程化水平和性能表现。这些技巧是区分初级与中高级开发者的重要指标，对嵌入式和高性能开发尤为重要。
【C/C++】select、poll、epoll 实战对比：从 fd_set 到就绪事件列表
wycgi的博客
06-25 126
本文对比了三种I/O多路复用技术：select、poll和epoll。通过实现TCP服务器的三个版本，展示了它们的关键特性和差异。select使用fd_set位图管理连接，需要每轮重建集合并扫描全部fd；poll改用pollfd数组，无需重建集合但仍需扫描；epoll采用事件注册机制，内核维护兴趣集合，只返回就绪事件。性能上，epoll最适合大量长连接场景。文章还提供了编译运行方法和测试指令，帮助读者实践理解这三种技术的演进过程和应用场景。
【C++】004、C与C++的最核心的区别
最新发布
Tim_10的博客
06-26 173
struct结构体，他不是类，内部只有属性，没有方法，要给struct的对象的属性进行赋值，必须在外部的函数中，将该对象指针作为参数传递，在函数中进行对象属性值的赋值。C++支持面向对象（封装、继承、多态），泛型编程，，函数式（lambda）。C语言只能通过函数指针与void*来实现抽象，类型检查较弱，多态需要运行时传参，有一定开销且不直观。数据（struct封装）和操作（函数）是分离的，要操作数据，必须把数据指针传给函数。C++通过模板编程实现多态，在编译期生成代码，无运行时开销，也就是零开销抽象。
C++ NRVO
a353541382的博客
06-24 185
NRVO（Named Return Value Optimization，具名返回值优化）是 C++ 中一种编译器优化技术，旨在消除函数返回对象时产生的临时对象和多余的拷贝操作。它是 RVO（Return Value Optimization，返回值优化）的一种特例，专门处理返回"具名变量"（即有名字的局部变量）的场景。
C++11 可变函数模板，lambda函数,C++新增
2302_80267820的博客
06-21 195
arg_list中的参数可能包含形如_n的名字，其中n是⼀个整数，这些参数是占位符，表⽰ newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表⽰⽣成的可调⽤对象 中参数的位置：_1为newCallable的第⼀个参数，_2为第⼆个参数，以此类推。3.捕捉列表中的变量默认是被const修饰的，传值捕捉的元素即在lambda函数中不可改变，在参数列表后加mutable可以改变常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。
【CANN】-Ascend C 算子开发
子非鱼eva的博客
06-24 208
AscendC = 昇腾 AI Core 专用算子开发语言, 不是 CUDA for 昇腾. 它用 CopyIn → Compute → CopyOut 三段式 + 显式 TBuf/TQue 内存管理 + 用户写 Tiling 函数实现多核并行, 是 2026 年新算子项目的推荐方案.三个关键事实范式 = 三段式 + 显式数据搬运: 与 CUDA 完全不同, 数据从 Global 到 Local 必须显式DataCopyEnQue, 不是隐式访存性能 = Tiling 表写得好。
C++(链表二）
weixin_46669997的博客
06-26 161
● 如果你的应用场景主要集中在单向顺序处理数据,且对内存占用敏感,单向链表是更好的选择。解析:在循环链表中,插入一个新节点时,只需要找到一个已知节点,然后在该节点后插。解析:和单向链表一样,在循环链表中,删除一个节点需要找到该节点的前驱节点,然。(其中,next为节点的直接后继,prev为节点的直接前驱)D。2、【真题】在一个双向链表中,p指向链表中的一个节点,s指向一待插入。2、在至少有2个节点的循环链表中,如果要删除一个节点,以下步骤正。在单向链表的每个节点添加一个指向前驱节点的指针,就得到双向链表。
算法模版（C++ 版）更新版
weixin_50923989的博客
06-22 237
本文总结了算法笔试和面试中常见的模板题及实现代码，主要包括以下内容： 序列操作（增删改查、排序等） 快速排序算法实现（重点讲解分区操作和递归实现） 判断素数的优化算法（基于6k±1原理） 文章提供了完整代码实现和关键注意事项，如： 快速排序中基准值随机化的重要性 判断素数时的数值范围处理 常见边界条件的处理方式 这些模板题和算法实现是算法面试的基础内容，掌握它们有助于提升算法能力，应对技术面试。
【C++】面试：多线程并发
DevFrank的博客
06-21 368
本文系统梳理了C++中高级面试核心知识点，涵盖多线程编程（线程创建、互斥锁、条件变量、原子操作）、C++11新特性（lambda表达式、右值引用、完美转发）、模板编程（函数/类模板、特化）以及编译链接原理四大模块。重点包括：线程函数入口的四种形式、死锁的四大条件与解决方案、原子变量与锁的性能对比、移动语义的资源所有权转移机制、模板的编译期实例化特性，以及预处理/编译/汇编/链接的全流程解析。文章强调这些知识点在区分工程师技术深度和工程实战能力上的重要性，并配有高频面试问题解析，是C++开发者进阶必备的核心知
C++从零开始系列篇（三）：C++类和对象（上）——类的定义，类的实例化，类的大小，this指针，面试题分析
2502_94043640的博客
06-22 487
C++类对象——类的定义，访问限定符，类的实例化，类的大小，this指针，面试题分析
C++ STL 之迭代器体系详解
Rick_Theseusr的博客
06-26 260
C++ STL 迭代器体系摘要 C++ STL 迭代器作为算法与容器的桥梁，主要包含六大类别和四大适配器。迭代器通过标签分派在编译期决定算法路径，适配器统一了不同操作接口。核心内容包括： 迭代器适配器： 插入迭代器（back/front/inserter）将赋值转为插入操作 流迭代器包装I/O流为迭代器接口 反向迭代器实现逆向遍历 移动迭代器(C++11)支持资源转移 六大迭代器类别： 输入/输出迭代器（单次遍历） 前向迭代器（多次单向遍历） 双向迭代器（支持逆向遍历） 随机访问迭代器（支持随机跳转） 连续
C++ new T / new T() / new T(args) 完整区别
雪的季节
06-26 133
分两种情况：有无自定义无参构造函数cpp运行int a;// 无参构造// 有参构造cpp运行int x;new Data：x 随机脏值（默认初始化）new Data()：x 自动置 0（值初始化）
STL 文件快速读取与分层切片系统（MATLAB 实现）
yu8593958的博客
06-25 175
处理大型 STL 文件的 MATLAB 代码，包含快速读取、内存优化、分层切片、轮廓生成等功能。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值