Does operator have alway need to have arguments?

Question

33 33 C:\Users\gauthjer\AppData\Local\Temp\Temp1_Ok.zip\rectangles.cpp [Error] 'rectangle operator++()' must have an argument of class or enumerated type

I created a program and the latter want to register a compiler error. My question is: Is an surcharge operator (overrriding) have alway needed arguments?

#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>

using namespace std ; 

class rectangle{

    double longueur;
    double largeur;

    public : 

    rectangle(double a = 0, double b = 0){ longueur = a; largeur = b; }

    void setDimension(double longu, double larg);
    double getLong() const;
    double getLarg() const;
    double surface() const;
    double perimeter()const;

    friend ostream & operator << (ostream &, const rectangle & flot);
    friend istream & operator >> (istream &, rectangle & flot);
    friend rectangle operator + (rectangle, rectangle);
    friend rectangle operator * (rectangle, rectangle);
    friend rectangle operator == (rectangle, rectangle);
    friend rectangle operator != (rectangle, rectangle);
    **friend rectangle operator ++  ();**
    friend rectangle operator ++  (int);
};

// Je dois utiliser longu au lieu de long comme demande dans le tp - long est un type d'argument (comme double)
void rectangle :: setDimension(double longu, double larg) {
    longueur = longu;
    largeur = larg;
}

void rectangle :: getLong() const{

    return longueur; 
}

void rectangle :: getLarg() const{

    return largeur; 
}

void rectangle :: surface() const{

    return longueur * largeur;
}

void perimeter :: perimeter() const{

    return 2*longeur + 2*largeur;
}

ostream & operator << (ostream & sortie, const rectangle & flot){

sortie << "(" << flot.longueur << "," << flot.largeur << ")";
return sortie;
}

istream & operator >> (istream & entree, rectangle & flot){

    char c = '\0';
    int longueur, largeur;
    bool ok = true;
    entree >> c; 
    if(c != '(') ok = false;
        else{ 
        entree >> longeur >> c;
            if (c != ',') ok = false;
                else{
                    entree >> largeur >> c;
                    if (c != ')') ok = false;
                }
        }
if(ok)  {flot.setDimension(longueur, largueur)}
    else entree.clear(ios::badbit | entree.rdstate() );
    return entree;

}

rectangle operator + (rectangle a, rectangle b){
    rectangle rectangle1;

    rectangle.longueur = a.longueur + b.longueur;
    rectangle.largeur = b.largeur + b.largeur; 
    return rectangle1;  
}

rectangle operator * (rectangle a, rectangle b){
    rectangle rectangle1;

    rectangle.longueur = a.longueur * b.longueur;
    rectangle.largeur = b.largeur * b.largeur; 
    return rectangle1;  
}

rectangle operator == (rectangle a, rectangle b){

    if (a.longueur == b.longueur && a.largeur == b.largeur) return true;
    else return false;  
}

rectangle operator != (rectangle a, rectangle b){

    if (a.longueur != b.longueur || a.largeur != b.largeur) return true;
    else return false; 
}


rectangle operator ++ (){

    longueur ++ ; largeur++ ; 
    return *this ;  
}

rectangle operator ++  (int n){
    rectangle rectangle1 = *this ;

    longueur++ ; largeur++ ;
    return rectangle ;  
}

The `++` operator shoudl be a member and not just a friend. If you have it as a free function, then on what object is it supposed to operate? — 463035818_is_not_an_ai, Nov 27 '15 at 14:00
@tobi303 It can be a non-member, `friend rectangle operator ++ (rectangle&);` — juanchopanza, Nov 27 '15 at 14:01
@juanchopanza I wasnt sure, because I usually avoid friends, thx for correcting me — 463035818_is_not_an_ai, Nov 27 '15 at 14:06
@juanchopanza: But it [should](http://stackoverflow.com/questions/4421706/operator-overloading/4421729#4421729) be a member. — sbi, Nov 27 '15 at 14:12
@J.G: I marked this as dupe. Feel free to ping me if/why you disagree. `:)` — sbi, Nov 27 '15 at 14:16
@sbi I agree with you; I found the answer to my question on 'Operator overloading'. — , Nov 27 '15 at 14:40

TartanLlama · Accepted Answer · 2015-11-27T14:06:31.210

2

Both pre- and post-fix versions of operator++ are best implemented as member functions rather than friend non-members, and the signature you have for declaring them as non-members is incorrect.

You should just remove the friend so that they are member functions and define them like this:

rectangle& rectangle::operator ++() {
//       ^ probably don't want to copy for pre-increment
    //...
}

rectangle rectangle::operator ++(int) {
    //...
}

edited Nov 27 '15 at 14:06

answered Nov 27 '15 at 14:01

TartanLlama

63,752
13
157
193

Your answer reads much better after the edit. – juanchopanza Nov 27 '15 at 14:06

eerorika · Answer 2 · 2015-11-27T14:28:04.010

Is an operator have alway needed arguments?

Yes. There are no nullary operators in c++. Even in the case of rectangle::operator ++() where the argument list appears empty, there is a hidden argument because it's a member-operator. Member operators, like member functions, have a hidden implicit object parameter. If you implement an operator as a firend, that object parameter must be part of the argument list explicitly.

If you want to define an overload for the pre-increment operator with the rectangle type, then the overload must have a single parameter of that type. Just like any other overload of the pre-increment operator:

friend rectangle operator ++(rectangle&);

Or declare it as a member function in which case the implicit object parameter is the only parameter.

Does operator have alway need to have arguments?

2 Answers2