精华内容
下载资源
问答
  • 今天在实验代码中遇到一个问题,那就是我的一个结构体

    教训:操作符重载需要面面俱到!

    今天在实验代码中遇到一个问题,set 的insert函数不能给我插入两个不一样的结构体,纠结了一下午最终发现是我的 < 操作符重载 出现问题,原代码段如下:

    ITEM item("S1 -> S",0,0,"#");
    ITEM item1("S1 -> S",0,0,"=");

    set<parser::ITEM> st1;
    st1.insert(item1);
    st1.insert(item);


    set<parser::ITEM>::iterator it;
    parser::ITEM xx;
    for(it=st1.begin(); it != st1.end(); it++)
     {
          xx = (*it);
           xx.print();//打印该结构体
    }

    此时< 操作符重载函数如下:

    bool LR_ITEM::operator<(const LR_ITEM & item)const
    {
        if(item.GetNum() < NUM)return true;
        else return item.POS < POS;
    }

    此时set之中只有item2。若上述函数改为:

    bool LR_ITEM::operator<(const LR_ITEM & item)const
    {
        if(item.GetNum() < NUM)return true;
        else if(item.GetNum() == NUM)
        {
            if(item.GetPos() == POS)return item.exp_symbol < exp_symbol;
            else return item.GetPos() < POS;
        }
    }

    可以得到预想的结果。

    展开全文
  • 首先结构体和类是有相似的地方的,可以进行运算符重载。 下面以=为例, #include using namespace std; struct P { int a; int b; //虽然已经对结构体进行=重载,但是这里只是举一个例子而已 P& operator=(P...

    首先结构体和类是有相似的地方的,可以进行运算符重载。

    下面以=为例,

    #include<iostream>
    using namespace std;
    struct P
    {
    	int a;
    	int b;
    	//虽然已经对结构体进行=重载,但是这里只是举一个例子而已
    	P& operator=(P& temp)
    	{
    		a=temp.a;
    		b=temp.b;
                    return *this;
            }
    };
    int main()
    {
    	P p={1,2};
            P x;
            x=p;
            cout<<x.a;//输出:1
    	return 0;
    }
    还有结构体运算符的重载是不能用友元函数来重载的,因为友元是针对类,结构体虽和类相似,但是毕竟不是类,也无法和类“相等”。

    不过我也发现可以在结构体内写个构造函数等。。

    #include<iostream>
    using namespace std;
    struct P
    {
    	int a;
    	int b;
    
    	//P(){}
    	//P(int x,int y):a(x),b(y){}
    	P(int x=0,int y=0):a(x),b(y){}
            void ShowAdd(){cout<<a+b<<endl;}
     };
    int main()
    {
    	P temp;//right
            //P p1={1,2};//error
            P p2(1,2);//right
            p.ShowAdd();//输出:3
            cout<<p.a<<endl;//输出:1
            return 0;
    }

    这样的话,结构体几乎就和类一样了。注意结构体中定义的变量和方法是public的。

    这里要解释下下面这几句代码:

    //P(){}
    //P(int x,int y):a(x),b(y){}
    P(int x=0,int y=0):a(x),b(y){}
    如果你写了第三行的代码,那就千万不要写第一第二行,为什么?放你编译器运行看看吧,这里只是提个醒,不作解释,很简单。

    展开全文
  • 首先结构体和类是有相似的地方的,可以进行运算符重载。 下面以=为例, #include using namespace std; struct P { int a; int b; //虽然已经对结构体进行=重载,但是这里只是举一个例子而已 P& ...

    首先结构体和类是有相似的地方的,可以进行运算符重载。

    下面以=为例,

    #include<iostream>  
    using namespace std;  
    struct P  
    {  
        int a;  
        int b;  
        //虽然已经对结构体进行=重载,但是这里只是举一个例子而已  
        P& operator=(P& temp)  
        {  
            a=temp.a;  
            b=temp.b;  
                    return *this;  
            }  
    };  
    int main()  
    {  
        P p={1,2};  
            P x;  
            x=p;  
            cout<<x.a;//输出:1  
        return 0;  
    }  


    还有结构体运算符的重载是不能用友元函数来重载的,因为友元是针对类,结构体虽和类相似,但是毕竟不是类,也无法和类“相等”。

    不过我也发现可以在结构体内写个构造函数等。。


    #include<iostream>  
    using namespace std;  
    struct P  
    {  
        int a;  
        int b;  
      
        //P(){}  
        //P(int x,int y):a(x),b(y){}  
        P(int x=0,int y=0):a(x),b(y){}  
            void ShowAdd(){cout<<a+b<<endl;}  
     };  
    int main()  
    {  
        P temp;//right  
            //P p1={1,2};//error  
            P p2(1,2);//right  
            p.ShowAdd();//输出:3  
            cout<<p.a<<endl;//输出:1  
            return 0;  
    }  
    这样的话,结构体几乎就和类一样了。注意结构体中定义的变量和方法是public的。

    这里要解释下下面这几句代码

    //P(){}  
    //P(int x,int y):a(x),b(y){}  
    P(int x=0,int y=0):a(x),b(y){}  

    如果你写了第三行的代码,那就千万不要写第一第二行,为什么?放你编译器运行看看吧,这里只是提个醒,不作解释,很简单。

    结构体运算符重载

    1、定义结构体

    struct  Currency
    {
         int  Dollar;
         int  Cents;
    }

    2、重载IO输出操作,在结构体内部将输入操作的重载定义为友元函数重载

    friend  ostream &operator<<(ostream &out,Currency value);

    在结构体外部进行具体定义

    ostream& operator<<(ostream &out,Currency value)
    {
         out<< "The dollar = " <<value.Dollar<< " and The Cents = " <<value.Cents<<endl;
         return  out;
    }

    3、重载结构体的“=”操作符(在结构体内部)

    Currency& operator=(Currency& value)
         {
             Dollar = value.Dollar;
             Cents = value.Cents;
             return  * this ;
         }

    4、重载结构体的“+”操作符(在结构体内部)

    Currency& operator+(Currency& value)
         {
             Dollar += value.Dollar;
             Cents += value.Cents;
             return  * this ;
         }

    5、重载结构体的"-"操作符(在结构体内部)

    Currency &operator-(Currency& value)
         {
             Dollar = Dollar - value.Dollar;
             Cents = Cents - value.Cents;
             return  * this ;
         }

    6、重载结构体的“*”操作符(在结构体内部)

    Currency& operator*(Currency& value)
         {
             Dollar *= value.Dollar;
             Cents *= value.Cents;
             return  * this ;
         }

    7、定义函数模板格式的输出函数

    template  < typename  T>
    void  DisplayValue(T value)
    {
         cout<<value<<endl;
    }

    8、进行运行测试。。。

    Currency c1;
    c1.Dollar = 10;
    c1.Cents = 5;
    DisplayValue(c1);
    Currency c2,c3;
    c2 = c1;
    c3= c1+c2;
    DisplayValue(c3);

    附上完整程序代码。。。

    #include "stdafx.h"
    #include <iostream>
    using  namespace  std;
     
    template  < typename  T>
    void  DisplayValue(T value)
    {
         cout<<value<<endl;
    }
     
    struct  Currency
    {
         int  Dollar;
         int  Cents;
         
         Currency& operator=(Currency& value)
         {
             Dollar = value.Dollar;
             Cents = value.Cents;
             return  * this ;
         }
         Currency& operator+(Currency& value)
         {
             Dollar += value.Dollar;
             Cents += value.Cents;
             return  * this ;
         }
         Currency &operator-(Currency& value)
         {
             Dollar = Dollar - value.Dollar;
             Cents = Cents - value.Cents;
             return  * this ;
         }
         Currency& operator*(Currency& value)
         {
             Dollar *= value.Dollar;
             Cents *= value.Cents;
             return  * this ;
         }
         friend  ostream &operator<<(ostream &out,Currency value);
    };
     
    ostream& operator<<(ostream &out,Currency value)
    {
         out<< "The dollar = " <<value.Dollar<< " and The Cents = " <<value.Cents<<endl;
         return  out;
    }
    int  _tmain( int  argc, _TCHAR* argv[])
    {
     
         Currency c1;
         c1.Dollar = 10;
         c1.Cents = 5;
         DisplayValue(c1);
         Currency c2,c3;
         c2 = c1;
         c3= c1+c2;
         DisplayValue(c3);
         system ( "pause" );
         return  0;
    }

    The end...

    结构体中定义函数指针

    转自:http://blog.csdn.NET/unix21/article/details/9293877

    结构体指针变量的定义,定义结构体变量的一般形式如下:

    形式1:先定义结构体类型,再定义变量
    struct结构体标识符
    {
    成员变量列表;…
    };
    struct 结构体标识符 *指针变量名;

    变量初始化一:struct结构体标识符 变量名={初始化值1,初始化值2,…, 初始化值n };


    形式2:在定义类型的同时定义变量
    struct结构体标识符
    {
    成员变量列表;…
    } *指针变量名;

    变量初始化二:


    形式3:直接定义变量,用无名结构体直接定义变量只能一次
    struct
     {
    成员变量列表;…
    }*指针变量名;


    其中“指针变量名”为结构体指针变量的名称。形式1是先定义结构体,然后再定义此类型的结构体指针变量;形式2和形式3是在定义结构体的同时定义此类型的结构体指针变量。


    函数指针的定义

      一般的函数指针可以这么定义:

      int(*func)(int,int);

      表示一个指向含有两个int参数并且返回值是int形式的任何一个函数指针. 假如存在这样的一个函数:

      int add2(int x,int y)

      {

      return x+y;

      }

      那么在实际使用指针func时可以这样实现:

      func=&add2; //指针赋值,或者func=add2; add2与&add2意义相同

      printf("func(3,4)=%d\n",func(3,4));

      事实上,为了代码的移植考虑,一般使用typedef定义函数指针类型.

      typedef int(*FUN)(int,int);

      FUN func=&add2;

      func();



    结构体中包含函数指针

    其实在结构体中,也可以像一般变量一样,包含函数指针变量.下面是一种简单的实现.

    #include <stdio.h>  
    struct DEMO  
    {  
    int x,y;  
    int (*func)(int,int); //函数指针  
    };  
      
    int add1(int x,int y)  
    {  
    return x*y;  
    }  
      
    int add2(int x,int y)  
    {  
    return x+y;  
    }  
      
    void main()  
    {  
    struct DEMO demo;  
    demo.func=add2; //结构体函数指针赋值  
    //demo.func=&add2; //结构体函数指针赋值  
    printf("func(3,4)=%d\n",demo.func(3,4));  
    demo.func=add1;  
    printf("func(3,4)=%d\n",demo.func(3,4));  
    }  
      
    /* 
    输出: 
    func(3,4)=7 
    func(3,4)=12 
    */  

    结构体中指向函数的指针                                          

    C语言中的struct是最接近类的概念,但是在C语言的struct中只有成员,不能有函数,但是可以有指向函数的指针,这也就方便了我们使用函数了。举个例子,如下:
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <string.h>  
      
    typedef struct student  
    {  
        int id;  
        char name[50];   
        void (*initial)();  
        void (*process)(int id, char *name);  
        void (*destroy)();  
    }stu;  
      
    void initial()  
    {  
        printf("initialization...\n");  
    }  
      
    void process(int id, char *name)  
    {  
        printf("process...\n%d\t%s\n",id, name);  
    }  
      
    void destroy()  
    {  
        printf("destroy...\n");  
    }  
      
    int main()  
    {  
        stu *stu1;  
        //在VC和TC下都需要malloc也可以正常运行,但是linux gcc下就会出错,为段错误,必须malloc  
        stu1=(stu *)malloc(sizeof(stu));  
        //使用的时候必须要先初始化  
        stu1->id=1000;  
        strcpy(stu1->name,"C++");  
        stu1->initial=initial;  
        stu1->process=process;  
        stu1->destroy=destroy;  
        printf("%d\t%s\n",stu1->id,stu1->name);  
        stu1->initial();  
        stu1->process(stu1->id, stu1->name);  
        stu1->destroy();  
        free(stu1);  
        return 0;  
    }  

    输出:

    /*
    1000    C++
    initialization...
    process...
    1000    C++
    destroy...
    */

    C语言中,如何在结构体中实现函数的功能?把结构体做成和类相似,让他的内部有属性,也有方法
    这样的结构体一般称为协议类,提供参考: 
    struct { 
     int funcid; 
     char *funcname; 
     int (*funcint)(); /* 函数指针 int 类型*/ 
     void (*funcvoid)(); /* 函数指针 void类型*/ 
    }; 
    每次都需要初始化,比较麻烦

    #include <stdio.h>  
      
    typedef struct  
    {  
    int a;  
    void (*pshow)(int);  
    }TMP;  
      
    void func(TMP *tmp)  
    {  
        if(tmp->a >10)//如果a>10,则执行回调函数。  
        {  
            (tmp->pshow)(tmp->a);  
        }  
    }  
      
    void show(int a)  
    {  
        printf("a的值是%d\n",a);  
    }  
      
    void main()  
    {  
        TMP test;  
        test.a = 11;  
        test.pshow = show;  
        func(&test);  
    }  
      
    /* 
    一般回调函数的用法为: 
    甲方进行结构体的定义(成员中包括回调函数的指针) 
     
    乙方定义结构体变量,并向甲方注册, 
    甲方收集N个乙方的注册形成结构体链表,在某个特定时刻遍历链表,进行回调。 
    当 函数指针 做为函数的参数,传递给一个被调用函数, 
    被调用函数就可以通过这个指针调用外部的函数,这就形成了回调<p>一般的程序中回调函数作用不是非常明显,可以不使用这种形式</p><p>最主要的用途就是当函数不处在同一个文件当中,比如动态库,要调用其他程序中的函数就只有采用回调的形式 
    通过函数指针参数将外部函数地址传入来实现调用</p><p>函数的代码作了修改,也不必改动库的代码,就可以正常实现调用便于程序的维护和升级</p>*/  



    展开全文
  • 目录一,结构体申明以及操作符重载:二,外置比较函数传参方法:三,测试代码: 前言:结构体是比较常用的数据结构,构造函数有多种方法。 另外,结构体的比较常为基于多关键字的比较,我们可以通过内嵌方式和外部...

    前言:结构体是比较常用的数据结构,构造函数有多种方法。 另外,结构体的比较常为基于多关键字的比较,我们可以通过内嵌方式和外部定义两种方式实现结构体的多关键字比较

    一,结构体申明以及操作符重载:

    struct Node{
        int a;
        int b;
        Node() :a(), b(){}//构造函数1
        Node(int _a, int _b) :a(_a),b(_b){}//构造函数2
        void init(int _a,int _b){//构造函数3
            this->a=_a;
            this->b=_b;
        }
        //重载操作符,多用于结构体多关键字比较;
        bool operator < (const Node& N ) const{
            if(a==N.a)
            return b<N.b;
            else return a<N.a;
        }; 
    }q[10];
    

    二,外置比较函数传参方法:

    还有一种方法是申明cmp函数传参到sort()内
    不过这种方法相比于结构体内嵌比较函数而言速度慢

    bool cmp(Node x,Node y){
        if(x.a==y.a)
            return x.b<y.b;
        else return x.a<y.a;
    } 
    

    三,测试代码:

    #include <bits/stdc++.h>
    using namespace std;
    
    struct Node{
        int a;
        int b;
    
        Node() :a(), b(){}//构造函数1
        Node(int _a, int _b) :a(_a),b(_b){}//构造函数2
        void init(int _a,int _b){//构造函数3
            this->a=_a;
            this->b=_b;
        }
        //重载操作符,多用于结构体多关键字比较;
        bool operator < (const Node& N ) const{
            if(a==N.a)
            return b<N.b;
            else return a<N.a;
        }; 
    
    }q[10];
    
    bool cmp(Node x,Node y){
        if(x.a==y.a)
            return x.b<y.b;
        else return x.a<y.a;
    } 
    
    int main(){
        for(int i=0; i<10; i++){
            int a=rand();
            int b=rand();
            q[i]=Node(a,b);
            printf("%d %d\n",q[i].a,q[i].b);
        }
        printf("\n");
        
        sort(q,q+10,cmp);//这里可以不用cmp
    
        for(int i=0; i<10; i++){
            printf("%d %d\n",q[i].a,q[i].b);
        }
        return 0;
    }
    

    输出:

    41 18467
    6334 26500
    19169 15724
    11478 29358
    26962 24464
    5705 28145
    23281 16827
    9961 491
    2995 11942
    4827 5436
    
    41 18467
    2995 11942
    4827 5436
    5705 28145
    6334 26500
    9961 491
    11478 29358
    19169 15724
    23281 16827
    26962 24464
    
    展开全文
  • 结构体重载输入输出运算符

    千次阅读 2019-08-07 21:01:54
    可以直接输入结构体,顺便初始化; #include<bits/stdc++.h> using namespace std; struct node { int x, y, z; friend istream & operator >> (istream&, node &t) { cin >>...
  • 如果可以,请顺便给我一个对于结构体的点操作符和箭头操作符解释比较清楚详细的文章的链接。谢谢! struct DATA // 定义一个结构体类型:DATA { char key[10]; // 结构体成员:key char name[20]; // 结构体...
  • 1. 优先队列中元素的比较规则默认是按元素的值从大到小排序的,就是说队列中最大的元素总是位于队首,所以出队时...”操作符的函数可以写在结构体里面,也可以写在结构体外面,写在结构体外面的时候,记得函数的参...
  • 结构体运算符重载

    千次阅读 2014-08-26 21:15:45
    1、定义结构体 struct Currency { int Dollar; int Cents;...2、重载IO输出操作,在结构体内部将输入操作的重载定义为友元函数重载 ...在结构体外部进行具体定义 ...3、重载结构体的“=”操作符(在结构
  • C++ operator关键字(重载操作符结构体中运算符的重载
  • 1.Template //函数模板 template <typename T> T qp(T a,ll n){ T ans=1; while(n){ if(n&1) ans*=a; a*=a; n>>=1;...2.重载操作符 3,内联函数 4.结构体构造函数 ...
  • 缺点:只能读取指定数目的元素,因为数组是固定长度的。希望容器掌握好后,用容器来处理。。 #include #include #include #include using namespace std; struct Score { char num[14];... friend istream
  • STL--重载操作符与qsort排序

    千次阅读 2012-07-12 22:09:04
    注意,用sort排序的时候,传的是...然后就是在结构体重,重载操作符,注意在结构体中,如果想按一定的规律排序是必须重载操作符的,包括 重载操作符下面是用qsort写的. 代码如下: #include #include #include #inclu
  • 1 概述 operator是C++的关键字,它和运算符一起使用,表示一个运算符函数,理解时应将operator=整体上视为一个函数名。 这是C++扩展运算符功能的方法,虽然样子古怪,但也...(1)为什么要对运算符进行重载: ...
  • /**用结构体指针我该如何调用重载操作符呢?**/ if(pOperate->one) cout << "one is true" << endl; else cout << "one is false" << endl; return 0; }
  • C++ 重载操作符基础

    千次阅读 2009-08-02 16:23:00
    概念: 通过操作符重载,可以针对类类型的操作数定义不同的操作符版本。如果只依靠使用IO使用命名函数以下的情况将无法避免。 cout.print("The sum of ").print(v1).print(" and "). print(v2).print(" is ")....
  • 操作符重载

    2014-08-20 19:21:58
    在c++中,定义一个结构体重载操作符==,但是
  • 在结构体内重载操作符: bool operator (const time &b) const {} 其中返回值 类型:bool; operator —— 表示重载<运算符; const time &b  —— 参数内部的const是为了防止引用变量被改动,...
  • 操作符重载 – 上 --- C++标准库、操作符重载、友元
  • 操作符重载

    2017-08-19 10:54:24
    Swift中的操作符重载比较简单,只需要在结构体或类中定义并实现重载的方法即可,单目操作符传入一个参数、双目操作符传入两个参数。实例如下: // 定义一个结构体 struct p { var x: Int var y: Int //重载+...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,331
精华内容 7,332
关键字:

结构体重载操作符