структура против классов

Question

// By using structure :     
struct complex {
  float real;
  float imag;
};    

complex operator+(complex, complex);    

main() { 
  complex t1, t2, t3;    
  t3 = t1 + t2;    
}    

complex operator+(complex w, complex z) {
  statement 1;    
  statement 2;   
}    

// By using class :    
class complex {
  int real;
  int imag;    

public:    
  complex operator+(complex c) {
    statement 1;    
    statement 2;    
  }    

  main() {    
    complex t1, t2, t3;    
    t3 = t1 + t2;    
  }    

При использовании структуры перегруженная функция может принимать два аргумента, тогда как при использовании класса перегруженная функция принимает только один аргумент, когда перегруженная операторная функция является функцией-членом в обоих случаях, т.е. как в структуре, так и в классе. Почему это происходит?

Answer 1

Это не имеет ничего общего с классами против структур. Это о члене против не члена.

Классы и структуры в C ++ отличаются исключительно по уровню доступности по умолчанию для членов и баз (общедоступный для структур и закрытый для классов). Кроме этого, нет никакой разницы .

При перегрузке операторов у вас почти всегда есть выбор определения оператора как члена или как автономной функции. Есть только 4 оператора, которые должны быть членами. Это: (), [], -> и = (почему, см. этот мой вопрос ). В остальном выбор за вами.

В этой превосходной записи FAQ объясняется (среди прочего), как выбирать между участником и не членом.

Чтобы ответить на ваш основной вопрос: в случае функции-члена первый аргумент будет *this

Answer 2

... когда перегруженная операторная функция является функцией-членом в обоих случаях, т.е. как структура, так и класс ...

Что заставляет вас это говорить?Это не правда.

В случае struct в вашем примере перегруженная операторная функция не член.Вот почему требуется 2 параметра.

Итак, разница не имеет абсолютно никакого отношения к структуре и классовой материи.Причина, по которой у этих операторов различное количество параметров, заключается в том, что первый реализован как не член (и поэтому имеет два явных параметра), а второй - как член (и поэтому имеет только один явный параметр).

Answer 3

//
complex operator +(cont complex& lhs, const complex& rhs)
{
  ...
}

main()  
{ 
  complex t1,t2,t3;    
  t3=t1+t2; // i.e. t3 = operator+(t1, t2);
}

// 
class complex
{ 
  int real,imag;    
public:    
  complex operator +(const complex& rhs){}
};

main()    
{    
  complex t1,t2,t3;    
  t3=t1+t2; // i.e. t3 = t1.operator+(t2);
}    

Answer 4

Во втором примере перегруженный оператор является функцией-членом класса, поэтому, когда этот оператор вызывается, он вызывается как функция-член первого операнда, и поэтому первый операнд неявно дается как объект, для которого член была вызвана функция (указатель this, если хотите).

Answer 5

Если вы хотите передать два аргумента перегруженному оператору +, вы должны создать функцию друга класса и затем передать const complex& lhs, const complex& rhs в качестве аргумента. Теперь вы можете иметь два аргумента для вашего operator+.

Когда operator+ является членом класса, один аргумент неявно передается как указатель this.

Answer 6

Это происходит потому, что вы используете разные методы для определения оператора. Когда вы используете структуру, вы определяете ее вне структуры, но когда вы используете класс, вы определяете оператор внутри класса.