Przeciążenie operatora +

Witam. Bawię się właśnie przeciążeniem operatorów i chce przykładowo napisać program w którym gdy będę dodawał zmienne typu MojTyp to będą one w rzeczywistości mnożone. Mam tu jednak chyba jakieś problemy ze składnią.

#include <iostream>

using namespace std;

class MojTyp
{
public:
    double zmienna;
    MojTyp(double z)
    {
        z=zmienna;
    }
};

MojTyp operator+(MojTyp a,MojTyp b)
{
    MojTyp suma;
    suma=a.zmienna*b.zmienna;
    return suma;
}

int main()
{
    return 0;
} 

Ktoś tu wie o co chodzi, bo jak na razie nie za bardzo ogarniam przeciążanie operatorów.

brakuje Ci konstruktora domyslnego

zawsze rob/napisz/zdefiniuj sobie tak zwana trojce na dzien dobry przy kazdej klasie
konstuktor domyslny
kostruktor kopiujacy
destruktor

Na przyszłość wklejaj błędy wypluwane przez kompilator, znacznie ułatwi to wszystkim życie.

Nie masz konstruktora domyślnego, a go używasz. Albo zaprzestań używania go, albo go zdefiniuj, trzeciej drogi nie ma. Przy okazji, powinieneś przyjmować argumenty przez const&, a nie przez kopię (chociaż akurat w tym przypadku ta regu​ła może nie mieć zastosowania - trzeba by było benchmarku).

Ja rozumiem, że przeciążanie operatorów to taka ładna błyskotka, na którą się rzuca każdy kto zaczyna.
Radzę jednak na razie skoncentrować swoje wysiłki na opanowaniu podstaw programowania obiektowego C++, wówczas bawienie się przeładowaniem operatorów przyjdzie samo.

Drugi problem to słuchaj kompilatora, on podpowiada w czym problem (clang jest w tym lepszy niż g++):

x.cpp:17:12: error: no matching constructor for initialization of 'MojTyp'
    MojTyp suma;
           ^
x.cpp:9:5: note: candidate constructor not viable: requires single argument 'z', but no arguments were provided
    MojTyp(double z)
    ^
x.cpp:5:7: note: candidate constructor (the implicit copy constructor) not viable: requires 1 argument, but 0 were provided
class MojTyp
      ^
1 error generated.

Jeden ze sposobów by to naprawić:

MojTyp operator+(const MojTyp &a, const MojTyp &b)
{
    MojTyp suma(a.zmienna*b.zmienna);
    return suma;
}

#include <iostream>

struct A
{
	int a;

	A operator+(A const& o) {
		return A{ this->a + o.a };
	}
};

int main()
{
	A a1 { 2 };
	A a2 { 3 };
	A a3 = a1 + a2;

	std::cout << a3.a;

	return 0;
}

Kod poprawiony przy minimalnej liczbie zmian:

#include <iostream>
 
using namespace std;
 
class MojTyp
{
public:
    double zmienna;
    
    MojTyp(double z)
    {
        zmienna = z;
    }
    
	MojTyp operator+(const MojTyp &b)
	{
	    double z = this->zmienna * b.zmienna;
	    return MojTyp(z);
	}
};
 
 
int main()
{
	MojTyp a(0.1);
	MojTyp b(0.3);
	cout << "Wynik: " << (a+b).zmienna << endl;
    return 0;
} 

Ogarnąłem liczbie zmian wystarzczy taki kod aby poprawnie działał.

#include <iostream>

using namespace std;

class MojTyp
{
public:
    double zmienna;
    MojTyp(double z)
    {
        zmienna=z;
    }
};

MojTyp operator+(MojTyp a,MojTyp b)
{
    MojTyp suma=a.zmienna*b.zmienna;
    return suma;
}

int main()
{
    MojTyp x(3);
    MojTyp y(6);
    MojTyp z(0);
    z=x+y;
    cout << z.zmienna;
    return 0;
}
 

Ogarnąłem! Przy minimalnej liczbie zmian wystarczy taki kod aby program poprawnie działał.

#include <iostream>

using namespace std;

class MojTyp
{
public:
    double zmienna;
    MojTyp(double z)
    {
        zmienna=z;
    }
};

MojTyp operator+(MojTyp a,MojTyp b)
{
    MojTyp suma=a.zmienna*b.zmienna;
    return suma;
}

int main()
{
    MojTyp x(3);
    MojTyp y(6);
    MojTyp z(0);
    z=x+y;
    cout << z.zmienna;
    return 0;
}