Moin,
ich möchte gerne in einer Klasse Operatoren überladen. Dazu habe ich mir eine einfache Klasse erstellt, die nur einen x und y Wert hat.
Angefangen habe ich erstmal mit einfachen Operatoren wie +=, ++(Postfix), ++(Prefix) und +.
Dazu erstmal meine Codebestandteile.
Meine Header-Datei
#ifndef _testOp_h
#define _testOp_h
#include "Arduino.h"
class TestOp {
public:
TestOp();
TestOp(uint32_t, uint32_t);
void init(uint32_t, uint32_t);
TestOp operator+=(const TestOp &v);
TestOp operator++(int); // Postfix-Operator
TestOp operator++(); // Prefix-Operator
//TestOp operator+(TestOp, TestOp); //??? muss friend sein
friend TestOp operator+(const TestOp&, const TestOp&);
void ink1(uint8_t*);
void ink2(uint8_t&);
void do1(void (*)());
void do2(void (&)());
uint32_t x;
uint32_t y;
private:
};
#endif
die dazugehörige cpp-Datei
#include "_testOp.h"
/** constructor **********************************************/
TestOp::TestOp() {
}
TestOp::TestOp(uint32_t x, uint32_t y) {
init(x, y);
}
/*************************************************************/
// methoden public ********************************************
void TestOp::init(uint32_t xi, uint32_t yi) {
x = xi;
y = yi;
}
TestOp TestOp::operator+=(const TestOp& v) {
x += v.x;
y += v.y;
return *this;
}
TestOp TestOp::operator++(int v) {
x++;
y++;
return *this;
}
TestOp TestOp::operator++() {
TestOp v = *this;
++x;
++y;
return v;
}
//TestOp TestOp::operator+(const TestOp& v1, const TestOp& v2) { //??? geht nicht
TestOp operator+(const TestOp& v1, const TestOp& v2) {
TestOp v;
v.x = v1.x + v2.x;
v.y = v1.y + v2.y;
return v;
}
void TestOp::ink1(uint8_t* v) {
//*v++; //??? geht nicht
*v += 1;
}
void TestOp::ink2(uint8_t& v) {
v++;
}
void TestOp::do1(void (*f)()) {
f();
}
void TestOp::do2(void (&f)()) {
f();
}
//*************************************************************
// methoden privat ********************************************
//*************************************************************
und zu guter letzt die ino-Datei zum Testen
#include "Arduino.h"
#include <_testOp.h>
TestOp var1(0,0);
TestOp var2(0,0);
TestOp var3(0,0);
uint8_t inkVar = 0;
void setup() {
Serial.begin(115200);
//Test 1 *****************************************************
send_test1(); // --> Ausgabe: var1.x = 0, var1.y = 0
var1++;
send_test1(); // --> Ausgabe: var1.x = 1, var1.y = 1
Serial.println();
//************************************************** bestanden
//Test 2 *****************************************************
send_test1(); // --> Ausgabe: var1.x = 1, var1.y = 1
++var1;
send_test1(); // --> Ausgabe: var1.x = 2, var1.y = 2
Serial.println();
//************************************************** bestanden
//Test 3 *****************************************************
send_test1(); // --> Ausgabe: var1.x = 2, var1.y = 2
send_test2(); // --> Ausgabe: var2.x = 0, var2.y = 0
var2 = ++var1;
send_test1(); // --> Ausgabe: var1.x = 3, var1.y = 3
send_test2(); // --> Ausgabe: var2.x = 2, var2.y = 2
Serial.println();
//************************************************** bestanden
//Test 4 *****************************************************
send_test1(); // --> Ausgabe: var1.x = 3, var1.y = 3
send_test2(); // --> Ausgabe: var2.x = 2, var2.y = 2
var2 = var1++;
send_test1(); // --> Ausgabe: var1.x = 4, var1.y = 4
send_test2(); // --> Ausgabe: var2.x = 4, var2.y = 4
Serial.println();
//************************************************** bestanden
//Test 5 *****************************************************
send_test1(); // --> Ausgabe: var1.x = 4, var1.y = 4
send_test2(); // --> Ausgabe: var2.x = 4, var2.y = 4
send_test3(); // --> Ausgabe: var3.x = 0, var3.y = 0
var3 = var1 + var2;
send_test1(); // --> Ausgabe: var1.x = 4, var1.y = 4
send_test2(); // --> Ausgabe: var2.x = 4, var2.y = 4
send_test3(); // --> Ausgabe: var3.x = 8, var3.y = 8
Serial.println();
//************************************************** bestanden
//Test 6 *****************************************************
Serial.println(inkVar); // --> Ausgabe: inkVar = 0
var1.ink1(&inkVar);
Serial.println(inkVar); // --> Ausgabe: inkVar = 1
var1.ink2(inkVar);
Serial.println(inkVar); // --> Ausgabe: inkVar = 2
Serial.println();
//************************************************** bestanden
//Test 7 *****************************************************
var1.do1(&f1); // --> Ausgabe: f1
var1.do2(f2); // --> Ausgabe: f2
//************************************************** bestanden
}
void loop() {
}
void send_test1() {
Serial.print("var1 -> x: ");
Serial.print(var1.x);
Serial.print(", y: ");
Serial.println(var1.y);
}
void send_test2() {
Serial.print("var2 -> x: ");
Serial.print(var2.x);
Serial.print(", y: ");
Serial.println(var2.y);
}
void send_test3() {
Serial.print("var3 -> x: ");
Serial.print(var3.x);
Serial.print(", y: ");
Serial.println(var3.y);
}
void f1() {
Serial.println("f1");
}
void f2() {
Serial.println("f2");
}
Das überladen der Operatoren klappt auch soweit super. Allerdings verstehe ich nicht, wieso ich bei dem überladen des + Operators den Aufruf in der Header-Datei (Zeile 17) als friend deklarieren muss. Außerdem muss ich in der cpp-Datei den Operator global deklarieren (Zeile 40) und nicht wie in Zeile 39 lokal, wie auch bei den anderen Operatoren. Hat jemand eine Erklärung dafür?
Irgendein Unterschied muss da ja sein.
Dann ist mir noch aufgefallen, dass ich den Inhalt eines Zeiger nicht mit *v++ inkrementieren kann. Mit *v+=1 funktioniert es.
Soll das so sein?
Letzte Frage. Ich habe mir zwei Methoden erstellt, um eine Variable zu inkrementieren, Zeile 47 und 52 in der cpp-Datei. Unterschied ist hier nur der übergene Parameter, bei ink1 ein Zeiger und bei ink2 die Speicheradresse.
Beides funktioniert, aber welche sollte man besser verwenden und warum? Eine Frage des Geschmacks? Bei einer Funktions-Übergabe funktionieren auch beide Methoden.
Das wars dann erstmal.
Schöne Grüße
Christian
