首页
学习
活动
专区
工具
TVP
发布
精选内容/技术社群/优惠产品,尽在小程序
立即前往

重载指针的operator++

++是一种C++语言中的运算符重载操作,用于对指针进行自增操作。通过重载operator++函数,可以实现对指针的自增操作符++的自定义行为。

在C++中,指针可以通过自增操作符++来实现指向下一个内存位置的移动。默认情况下,指针的自增操作会使指针指向下一个相邻的内存位置。然而,通过重载operator++函数,我们可以改变指针自增操作的行为,使其按照我们的需求进行移动。

重载operator++函数时,需要注意以下几点:

  1. operator++函数应该返回一个指向当前对象的引用,以便支持连续的自增操作。
  2. operator++函数可以有一个额外的int参数,用于区分前置自增和后置自增操作符。前置自增操作符返回自增后的指针,而后置自增操作符返回自增前的指针。
  3. operator++函数可以在类的成员函数中定义,也可以作为全局函数进行定义。

下面是一个示例代码,展示了如何重载指针的operator++函数:

代码语言:cpp
复制
#include <iostream>

class MyPointer {
private:
    int* ptr;

public:
    MyPointer(int* p) : ptr(p) {}

    // 前置自增操作符重载
    MyPointer& operator++() {
        ++(*ptr);
        return *this;
    }

    // 后置自增操作符重载
    MyPointer operator++(int) {
        MyPointer temp = *this;
        ++(*ptr);
        return temp;
    }

    int getValue() {
        return *ptr;
    }
};

int main() {
    int value = 5;
    MyPointer ptr(&value);

    std::cout << "初始值: " << ptr.getValue() << std::endl;

    ++ptr; // 前置自增
    std::cout << "前置自增后的值: " << ptr.getValue() << std::endl;

    ptr++; // 后置自增
    std::cout << "后置自增后的值: " << ptr.getValue() << std::endl;

    return 0;
}

在上述示例代码中,我们定义了一个名为MyPointer的类,其中包含一个int类型的指针成员变量ptr。通过重载operator++函数,我们实现了前置自增和后置自增操作符的自定义行为。在main函数中,我们创建了一个MyPointer对象ptr,并对其进行前置自增和后置自增操作,最后输出自增后的值。

腾讯云相关产品和产品介绍链接地址:

页面内容是否对你有帮助?
有帮助
没帮助

相关·内容

【C++】函数重载 ③ ( 为函数指针赋值重载函数 )

博客总结 : 重载函数 : 使用 相同 函数名 , 定义 不同 函数参数列表 ; 判定标准 : 只有 函数参数 个数 / 类型 / 顺序 不同 是 " 函数重载 " 判断标准 , 函数... 返回值 不是 " 函数重载 " 判断标准 ; 二义性 : 如果 函数重载 与 默认参数 结合使用 , 出现了二义性 , 编译直接失败 ; 函数指针赋值重载函数 : 根据 函数指针 类型中 参数列表类型..., 自动匹配 重载函数 ; 一、函数指针回顾 1、函数指针概念 之前博客 【C 语言】指针 与 数组 ( 指针 | 数组 | 指针运算 | 数组访问方式 | 字符串 | 指针数组 | 数组指针 |...二、为函数指针赋值重载函数 ---- 1、为函数指针赋值重载函数 对 函数指针 进行赋值时 , 直接将 函数名 赋值给了 函数指针 ; 如 下面的代码中 , 直接将 add 函数赋值给了 函数指针 func_ptr...查找 参数列表是 2 个 int 类型函数 , 如果没有找到 , 就会编译失败 , 如果找到了 , 为函数指针赋值成功 ; 2、代码示例 - 为函数指针赋值重载函数 完整代码示例 : // 包含 C

27910
  • 【C++】运算符重载 ⑦ ( 一元运算符重载 | 后置运算符重载 | 使用 全局函数 实现 后置 ++ 自增运算符重载 | 使用 成员函数 实现 后置 -- 自减运算符重载 )

    与 后置运算符重载 区别 , 前置运算符重载 : Student& operator++(Student& s) , 返回是对象引用 , 参数正常 ; 后置运算符重载 : Student operator..., 添加了 int 类型占位参数 ; operator++(Student& s, int) 再后 , 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 ; 实现 1 个 Student...指针指向对象值自减 ; Student operator--(int) 最后 , 实现函数体 , 编写具体运算符操作业务逻辑 ; public: // 使用 成员函数 实现 后置 -- 自减运算符重载...// 重载 后置 -- 运算符 // 实现 1 个 Student 对象 自减运算 // 先使用 this 指针指向对象 , 再自减 // 因此 this 指针指向对象 是需要自减...// 重载 后置 -- 运算符 // 实现 1 个 Student 对象 自减运算 // 先使用 this 指针指向对象 , 再自减 // 因此 this 指针指向对象 是需要自减

    19140

    C++运算符重载形式

    一、重载为类成员函数 重载单目运算符“++”,如果重载是前置运算符“++”,则++a1调用相当于调用函数a1.operator++()。...如果重载是后置运算符“++”,则运算符重载函数需要带一个整型参数,即“operator++(int)”,参数int仅仅表示后置运算,用于和前置运算区分,并无其他意义。...++(); //重载前置++ A operator++(int); //重载后置++ }; void A::show1() const { cout << "(_x,_y)=" <<...*表示<em>的</em>解引用,那么*this就很好理解了,就是<em>指针</em><em>的</em>内容,即对象本身。 那他<em>的</em>用途是在哪呢?...二、<em>重载</em>为类<em>的</em>友元函数 <em>重载</em>为类<em>的</em>友元函数时,由于没有隐含<em>的</em>this<em>指针</em>,因此操作数<em>的</em>个数没有变化,所有的操作数都必须通过函数<em>的</em>参数进行传递,函数<em>的</em>参数与操作数自左至右保持一致。

    76150

    C++初阶学习第十一弹——探索STL奥秘(六)——深度刨析list用法和核心点

    (vector使用也要注意这个问题) 内存效率: list内存效率相对较高,因为它不需要像数组那样连续分配内存,但是它插入和删除操作时间复杂度为O(1),这是因为链表每个元素都需要存储指向前后节点指针...指针可以解引用,迭代器类中必须重载operator*() 2. 指针可以通过->访问其所指空间成员,迭代器类中必须重载oprator->() 3....指针可以++向后移动,迭代器类中必须重载operator++()与operator++(int) 至于operator--()/operator--(int)释放需要重载,根据具体结构来抉择,双向链表可以向前...移动,所以需要重载,如果是forward_list就不需要重载-- 4....迭代器需要进行是否相等比较,因此还需要重载operator==()与operator!

    9710

    C++:12---运算符重载

    保护都可以 友元函数:同上 全局函数:只能访问公有的 三、运算符重载规则 C++98,C++0x,C++11对“哪些运算符重载能够重载”有一致规定。...它被定义用于为一个类赋予"指针"行为。运算符 -> 必须是一个成员函数。如果使用了 -> 运算符,返回类型必须是指针或者是类对象。...运算符 -> 通常与指针引用运算符 * 结合使用,用于实现"智能指针"功能。这些指针是行为与正常指针相似的对象,唯一不同是,当您通过指针访问对象时,它们会执行其他任务。...X *operator->();}; 类 Ptr 对象可用于访问类 X 成员,使用方式与指针用法十分相似。...++(int) // 后缀版本 { return operator++(); } // 重载运算符 -> Obj* operator->() const {

    59430

    【C++】模拟实现reverse_iterator(反向迭代器适配器)

    reverse_iterator提供功能有: reverse_iterator构造函数 operator++函数重载 operator++(int)函数重载 operator--函数重载 operator...++操作其实是底层iterator--操作,我们直接调用iterator函数接口即可,前置++返回++后结果,所以我们操作完直接返回*this指针即可,代码如下: self operator++...() { --_it; return *this; } 实现operator++(int)函数重载 因为是逆向遍历,reverse_iterator++操作其实是iterator...iterator++操作,我们直接调用iterator函数接口即可,前置--返回--后结果,所以我们操作完直接返回*this指针即可,代码如下: self operator--() { ++_it...: 那么正常情况下我们想要获得当前指针值,就要去解引用该指针前一个位置值,要解引用前一个位置,可以直接调底层iterator*和--函数,注意*操作_it不能改变,所以我们创建一个变量

    8310

    【C++】运算符重载 ⑤ ( 一元运算符重载 | 使用 成员函数 实现 前置 ++ 自增运算符重载 | 使用 成员函数 实现 前置 - - 自减运算符重载 )

    一、一元运算符重载 1、使用 成员函数 实现 前置 ++ 自增运算符重载 使用 全局函数 实现 前置 ++ 自增运算符重载 : 首先 , 写出函数名 , 函数名规则为 " operate " 后面跟上要重载运算符..., 因此没有参数 ; operator++() 再后 , 根据业务完善返回值 , 返回值可以是 引用 / 指针 / 元素 , 如 : 返回值是元素 Student operate+(Student&...; Student& operator++() 最后 , 实现函数体 , 编写具体运算符操作业务逻辑 ; // 使用 成员函数 实现 前置 ++ 自增运算符重载 // 重载 前置 ++ 运算符...// 实现 1 个 Student 对象 自增运算 // 由于 参数中 Student& s 中属性发生了变化 // 返回时仍需要返回 Student& s 参数本身 Student& operator...s 参数本身 Student& operator++() { this->age++; this->height++; // 此处返回引用类型 , 需要对 this 指针进行解包 return

    18140

    C++中运算符重载

    运算符重载相当于运算符函数重载,用于对已有的运算符进行重新定义,赋予其另一种功能,以适应不同数据类型。...我们之前提到过C++中函数重载,可以根据形参不同调用不同函数,那么运算符重载跟函数重载实现形式差不多,运算符重载一般写法为返回值 operator运算符(参数列表)。...输出结果如下: name: 张三 age: 52 1.2 全局函数写法 在成员函数写法中,由于在调用加法重载时已经指定了一个对象 ( this 指针指向对象 ),所以重载函数内只需要再传递一个参数即可...在这里如果对引用不是很清楚可以移步另一篇文章:C++中指针与引用详解 - ZhiboZhao - 博客园 (cnblogs.com)。...p2: name: 李四 age: 28 // 自增之后 3.2 全局函数写法 需要注意是,由于全局函数不属于任何一个对象,因此形参为引用或者指针传递时才能修改原数据。

    88400

    C++ 重载运算符 继承 多态 (超详细)

    (3) 友元函数重载+重载输入输出流(用稀烂用多比较重要) 在左右操作数类型不同时上述重载方式都不能正常使用,这时候就需要两个操作数,在类外重载,因类外不能直接调用,所以要把该函数声明为类友元。...用非类A类型值为类A对象赋值时(当然,这种情况下我们可以不提供相应赋值运算符重载函数,而只提供相应构造函数,如更有重载函数会优先调用重载赋值运算符)。...当用类A类型值为类A对象赋值,且类A数据成员中含有指针情况下,必须显式提供赋值运算符重载函数。...赋值兼容应注意问题: 指向基类指针可以指向公有派生类对象,但不允许指向它私有派生类对象。...允许将一个声明为指向基类指针指向其公有派生类对象,但是不能将一个声明为指向派生类对象指针指向基类对象。

    1.1K21

    类与对象 中(剩余部分) 以及 日历

    • 如果⼀个重载运算符函数是成员函数,则它第⼀个运算对象默认传给隐式this指针,因此运算符重载作为成员函数时,参数⽐运算对象少⼀个。...• 重载++运算符时,有前置++和后置++,运算符重载函数名都是operator++,⽆法很好区分。 C++规定,后置++重载时,增加⼀个int形参,跟前置++构成函数重载,⽅便区分。...• 重载>时,需要重载为全局函数,因为重载为成员函数,this指针默认抢占了第⼀个形参位 置,第⼀个形参位置是左侧运算对象,调⽤时就变成了对象<<cout,不符合使⽤习惯和可读性。...• const实际修饰该成员函数隐含this指针,表明在该成员函数中不能对类任何成员进⾏修改。...const修饰Date类Print成员函数,Print隐含this指针由 Date* const this 变为 const Date* const this 取地址运算符重载分为普通取地址运算符重载

    6310

    【C++】运算符重载 ④ ( 一元运算符重载 | 使用 全局函数 实现 前置 ++ 自增运算符重载 | 使用 全局函数 实现 前置 - - 自减运算符重载 )

    2 个对象引用 , 如 : operate+(Student& s1, Student& s2) operator++(Student& s) 再后 , 根据业务完善返回值 , 返回值可以是 引用.../ 指针 / 元素 , 如 : 返回值是元素 Student operate+(Student& s1, Student& s2) ; 此处 , 由于 参数中 Student& s 中属性发生了变化..., 返回时仍需要返回 Student& s 参数本身 , 因此返回值是 Student& 引用类型 ; Student& operator++(Student& s) 最后 , 实现函数体 , 编写具体运算符操作业务逻辑...为了使全局函数中能访问 Student 类私有成员 , 需要将该全局函数声明为 友元函数 ; // 使用 全局函数 实现 前置 ++ 自增运算符重载 friend Student& operator...Student& operator++(Student& s); // 使用 全局函数 实现 前置 -- 自增运算符重载 friend Student& operator--(Student& s

    18820

    【C++】类和对象(中)--下篇

    五、赋值运算符重载 1、运算符重载 运算符重载是具有特殊函数名函数,是C++为了增强代码可读性而引入 operator sign(parameter); operator为关键字,sign就是需要重载运算符符号...类成员函数重载时有一个隐藏参数this 不能重载五个运算符 .* :: sizeof ?...,所以在生成s2时,s2中指针a指向数组与s1中指针指向数组相同,在程序结束时,调用析构函数释放了s2,对应这块数组空间也被释放,然后调用析构函数释放s1,已经被释放空间不能被再次释放,所以出现了这样错误...是先赋值再+1 如果我们想要++重载,那么就是定义operator++,分不出为前置还是后置,所以我们规定operator++为前置++,operator++(int)为后置++ class Date...const成员函数,const实际修饰其中隐含this指针,表明在该成员函数中不能对类内任何成员进行修改 因为参数为隐藏,所以我们方法如下: void Date::Print() const {

    12410

    移情别恋c++ ദ്ദി˶ー̀֊ー́ ) ——2.类和对象(中(2))

    赋值运算符重载 5.1 运算符重载重载运算符函数参数个数和该运算符作⽤运算对象数量⼀样多。...• 如果⼀个重载运算符函数是成员函数,则它第⼀个运算对象默认传给隐式this指针,因此运算 符重载作为成员函数时,参数⽐运算对象少⼀个。...• 重载++运算符时,有前置++和后置++,运算符重载函数名都是operator++,⽆法很好区分。 C++规定, 后置++重载时,增加⼀个int形参,跟前置++构成函数重载,⽅便区分。...• const实际修饰该成员函数隐含this指针,表明在该成员函数中不能对类任何成员进⾏修改。...const 修饰Date类Print成员函数,Print隐含this指针由 Date* const this 变为 const Date* const this #include<iostream

    9910

    C++笔记:运算符重载

    运算符重载 运算符重载是通过定义函数实现,这种函数称为运算符重载函数,它通常是类成员函数或者友元函数。...(以双目运算符+为例) 重载函数为成员函数时,可以少写一个函数参数(通过this指针直接访问当前对象)。...不能重载运算符只有5个: 运算符符号 运算符含义 . 成员访问运算符 .* 成员指针访问运算符 :: 域运算符 sizeof 长度运算符 ?...~ ++ 为前置运算时 i++ ,运算符重载函数一般格式为: 类型 & operator++( ) , Complex & operator++(); //前置运算符 ++c ++ 为后置运算时...++i ,运算符重载函数一般格式为: 类型 operator++(int) //多了一个int型形参 Complex operator++(int index); //后置运算符 c++ 重载流运算符

    1.2K20

    双向链表类模板实现

    ,这里是常迭代器 //这里前置const规定了返回值不能修改,这里返回值是指针指向地址值,因此这里不能修改指针指向和指向值 const T& operator*()const...{ return const_iterator(tail); } //返回首元素引用---我们在迭代器函数里面重载了*,因此解引用迭代器返回是当前迭代器current指针指向data...*,因此解引用迭代器返回是当前迭代器current指针指向data数据域 //但注意返回应该是end迭代器前一个,即最后一个位置有效元素 //这里迭代器重载了--运算符,因此迭代器...const_iterator(tail); } //返回首元素引用---我们在迭代器函数里面重载了*,因此解引用迭代器返回是当前迭代器current指针指向data数据域 T&...*,因此解引用迭代器返回是当前迭代器current指针指向data数据域 //但注意返回应该是end迭代器前一个,即最后一个位置有效元素 //这里迭代器重载了--运算符,因此迭代器

    98410

    (转载非原创)C++中运算符重载

    我们之前提到过C++中函数重载,可以根据形参不同调用不同函数,那么运算符重载跟函数重载实现形式差不多,运算符重载一般写法为返回值 operator运算符(参数列表)。...输出结果如下: name: 张三 age: 52 1.2 全局函数写法 在成员函数写法中,由于在调用加法重载时已经指定了一个对象 ( this 指针指向对象 ),所以重载函数内只需要再传递一个参数即可...在这里如果对引用不是很清楚可以移步另一篇文章:C++中指针与引用详解 - ZhiboZhao - 博客园 (cnblogs.com)。...++(); // 前置自增运算符 void operator<<(ostream& cout); // 左移运算符重载 }; person person::operator++(){ age++;...p2: name: 李四 age: 28 // 自增之后 3.2 全局函数写法 需要注意是,由于全局函数不属于任何一个对象,因此形参为引用或者指针传递时才能修改原数据。

    75420

    C++第十二弹 -- STL之list模拟实现

    list迭代器 迭代器有两种实现方式, 具体应根据容器底层数据结构实现: 1.原生态指针, 比如:vector 2.将原生态指针进行封装, 因迭代器使用形式与指针完全相同, 因此在自定义类中必须实现以下方法...: 1.指针可以解引用,迭代器类中必须重载operator*() 2.指针可以通过->访问其所指空间成员,迭代器类中必须重载operator->() 3.指针可以++向后移动,迭代器类中必须重载...operator++()与operator++(int) 至于operator--()/operator--(int)释放需要重载,根据具体结构来抉择, 双向链表可以向前或者向后移动,所以需要重载...,如果是forward_list就不需要重载-- 4.迭代器需要进行是否相等比较,因此还需要重载operator==()与operator!...++() { _node = _node->_next; return *this; } Self operator++(int) { Self temp(*this

    6910

    【C++】深度解析:用 C++ 模拟实现 list 类,探索其底层实现细节

    list底层是双向链表结构,双向链表中每个元素存储在互不相关独立节点中,在节点中通过指针指向其前一个元素和后一个元素。...将原生态指针进行封装,因迭代器使用形式与指针完全相同,因此在自定义类中必须实现以下方法: 指针可以解引用,迭代器类中必须重载operator*() 指针可以通过->访问其所指空间成员,迭代器类中必须重载...oprator->() 指针可以++向后移动,迭代器类中必须重载operator++()与operator++(int) 至于operator--()/operator--(int)释放需要重载,根据具体结构来抉择...,双向链表可以向前移动,所以需要重载,如果是forward_list就不需要重载-- 迭代器需要进行是否相等比较,因此还需要重载operator==()与operator!...,为了区分前置和后置,我们会在后置重载函数中传缺省值int,从而与前置构成重载 局部变量不能返回引用 operator==与operator!

    6510

    【C++】函数重载 ④ ( 函数指针定义三种方式 | 直接定义函数指针 | 通过 函数类型 定义 函数指针 | 通过 函数指针类型 定义 函数指针 )

    博客总结 : 重载函数 : 使用 相同 函数名 , 定义 不同 函数参数列表 ; 判定标准 : 只有 函数参数 个数 / 类型 / 顺序 不同 是 " 函数重载 " 判断标准 , 函数... 返回值 不是 " 函数重载 " 判断标准 ; 二义性 : 如果 函数重载 与 默认参数 结合使用 , 出现了二义性 , 编译直接失败 ; 函数指针赋值重载函数 : 根据 函数指针 类型中 参数列表类型..., 自动匹配 重载函数 ; 一、函数指针定义方法 先定义一个函数 , 在本章节中使用不同方法 , 定义该函数 对应 函数指针 ; // 定义一个函数 int add(int a, int b)..., 定义函数指针 , 直接根据指针定义语法 指针类型* 指针名称 定义函数指针 , 同时将 add 函数 地址 赋值给 函数指针 ; // 根据 函数类型 定义 函数指针 func* func1...= add; 3、通过 函数指针类型 定义 函数指针 首先 , 通过 typedef 关键字, 定义 函数指针 类型 , 类型名称为 func_ptr , 对应函数 参数列表是 2 个 int 参数

    18030
    领券