Ich stehe vor einem Problem.
Ich habe in einer Klasse einige Vektoren. Zum Beispiel:

vector<int> a (4,0xFF);
vector<int> b (2,0x00);
vector<int> c;
vector<int> d;
vector<int> e;

Ich will bzw. muss diese Vektoren an unterschiedlichen Stellen in der Klasse zu einem neuen Vektor zusammensetzen können. Und das in beliebiger Reihenfolge.

Bisher mache ich das so:

vector<int> z;
z.insert(z.end(), b.begin(), b.end());
z.insert(z.end(), e.begin(), e.end());
z.insert(z.end(), b.begin(), b.end());

usw. usw. usw.
Viel lieber wäre mir aber solch eine Lösung:

vector<int> z;
z = b + e + b;

Jetzt endlich meine Frage
Kann ich den + Operator bei Vektoren überladen? Ich habe es schon auf die ein oder andere Weise probiert. Aber entweder bin ich da zu blöde für, oder es geht einfach nicht.

Solche Konstrukte hatte ich bisher in der Klasse definiert:

std::vector<int>& operator+(const std::vector<int>&);
std::vector<int>& operator+(const std::vector<int>);
std::vector<int> operator+(const std::vector<int>);
std::vector<int> operator+(const std::vector<int>&, const std::vector<int>&);

Aber das hat alles nur diverse Fehler produziert.

Ich gebe ehrlich zu, dass mit dem Überladen von Operatoren habe ich noch nicht so richtig verstanden. Allerdings muss ich bis Dienstag Abend irgendwie eine Lösung finden.

Bitte, kann einer von euch mir helfen?
Vielen lieben Dank!!

Gruß
Thorsten

template<class T>
vector<T> operator + (const vector<T>& v1, const vector<T>& v2)
{
	vector<T> v = v1;
	v.insert(v.end(), v2.begin(), v2.end());
	return v;
}

Dann musst du nur noch hoffen, dass dein Compiler Copy-Elison bzw. NRVO gut beherrscht

Edit: falls er das nicht tut, kann man sich eventuell sowas basteln:

template<class T>
vector<T>& operator += (vector<T>& to, const vector<T>& from)
{
	to.insert(to.end(), from.begin(), from.end());
	return to;
}

// ...

((z += b) += e) += b;

Das ist zumindest etwas übersichtlicher.

#include<vector>
#include<iostream> 

std::vector<int> operator+(const std::vector<int>& lhs, const std::vector<int>& rhs){
  std::vector<int> temp(lhs);
  temp.insert(temp.end(),rhs.begin(),rhs.end());
  return temp;
}

int main()
{
  std::vector<int> A (3,100);
  std::vector<int> B (0,200);
  std::vector<int> C = A+B;

  for (int i=0; i<C.size(); ++i) std::cout<<C[i]<<std::endl;
}

Natürlich noch schicker mit Templateparameter, anstatt nur für int.

edit: Oha, 10 Minuten zu spät. Ich sollte a) Beispiele schneller programmieren und b) mal prüfen ob inzwischen schon jemand anderes geantwortet hat, bevor ich abschicke.

template<typename T, class Alloc>
vector<T, Alloc>
operator+(vector<T, Alloc> lhs, vector<T, Alloc> const &rhs)
{
  lhs.reserve(lhs.size() + rhs.size());
  lhs.insert(lhs.end(), rhs.begin(), rhs.end());
  return lhs;
}

Ich find den Operator bei strings gar nicht so unpassend, denn ein solches addieren ist recht intuitiv verständlich, dass dort ein String angehängt wird.
Dass da nicht irgendwie eine Zeichenweise Addition statt findet ist denke ich recht klar.

Bei dem gezeigtem kann man sich natürlich streiten, aber dazu müssten wir noch mehr über den Hintergrund wissen.

edit: Oha, 10 Minuten zu spät. Ich sollte a) Beispiele schneller programmieren und b) mal prüfen ob inzwischen schon jemand anderes geantwortet hat, bevor ich abschicke.

Nein, fang sowas nicht an. Meistens ist die zweite Lösung doch in einem kleinen Detail anders, und dem Fragesteller ist durchaus damit gedient, verschiedene Stilrichtungen zu sehen.
Wenns im Prinzip nichts Neues ist, ist ein
edit: zu spät
sehr schick, um dem Erstantworter und allen anderen noch schnell zu sagen, daß man damit nicht widersprechen wollte und man auf die leicht andere Gangart nicht pocht.

@volkard: Ok, werde ich dran denken. Beziehungsweise einfach nichts anders machen als bisher.

@rüdiger:
Warum verändert deine Funktion ein Argument? - Für den +-Operator würde ich da eher die Variante von ipsec bevorzugen, was auch eher dem Verhalten von std::string entspricht.

Das erste Argument wird kopiert. Teilweise ist es für den Compiler einfacher, unnötige Kopien wegzuoptimieren, wenn die Kopie implizit (über Parameter oder Rückgabewert) erfolgt.

Das Verhalten von rüdigers Funktion ist analog zum operator+ bei std::string .

Habe spontan die Lösung von SeppJ ausprobiert, aber das läuft natürlich nicht bei mir. Also zumindest nicht innerhalb einer Klasse. Ich habe stellenweise echt Wissenslücken in C++.

In file included from main.cpp:2:
test.h:12: error: ‘std::vector<int, std::allocator<int> > Test::operator+(const std::vector<int, std::allocator<int> >&, const std::vector<int, std::allocator<int> >&)’ must take either zero or one argument

Liegt bestimmt wieder an der späten Stunde und meiner Doofheit. Also das hier ist die test.h:

#ifndef TEST_H
#define TEST_H

#include <vector>

class Test
{
  public:
    Test();    
    ~Test();

    std::vector<int> operator+(const std::vector<int>& lhs, const std::vector<int>& rhs);
    void testop();
};

#endif

Und das die passende test.cpp:

#include <vector>
#include <iostream>
#include "test.h"

std::vector<int> operator+(const std::vector<int>& lhs, const std::vector<int>& rhs){
  std::vector<int> temp(lhs);
  temp.insert(temp.end(),rhs.begin(),rhs.end());
  return temp;
} 

void Test::testop()
{
    std::vector<int> a (2,0xDD);
    std::vector<int> b (2,0xAA);
    std::vector<int> c ;

    c = a + b;
}

Gruß
Thorsten

Jedoch würde ich bei Addition von vectoren intuitiv eher eine elementweise Addition erwarten.

Ich weiß nicht. vector ist so eine eierlegende Wollmilchsau.
Die elementweise Addition würde ich gerne bei valarray sehen. valvector?

drakon schrieb:

@rüdiger:
Warum verändert deine Funktion ein Argument? - Für den +-Operator würde ich da eher die Variante von ipsec bevorzugen, was auch eher dem Verhalten von std::string entspricht.

Das erste Argument wird kopiert. Teilweise ist es für den Compiler einfacher, unnötige Kopien wegzuoptimieren, wenn die Kopie implizit (über Parameter oder Rückgabewert) erfolgt.

Das Verhalten von rüdigers Funktion ist analog zum operator+ bei std::string .

Stimmt. Hab da irgendwie ein & gesehen.

Elementweise Addition fände ich auch hier eher merkwürdig.

Mir fällt auch gerade kein gutes Operatorsymbol für eine Union zweier Mengen ein, da ich eigentlich überall elementweise Operationen erwarten würde.

Wie wäre es mit operator& oder operator, ? (Natürlich sollte man zu beiden noch einen Kommentar schreiben)

Aber ansonsten läuft es super. Vielen lieben Dank für eure Hilfe!!!

Gruß
Thorsten

Alternativ wäre es noch eine Möglichkeit das in einen namespace zu packen, aber ich denke, dass das nicht nötig ist.

drakon schrieb:

@rüdiger:
Warum verändert deine Funktion ein Argument? - Für den +-Operator würde ich da eher die Variante von ipsec bevorzugen, was auch eher dem Verhalten von std::string entspricht.

Das erste Argument wird kopiert. Teilweise ist es für den Compiler einfacher, unnötige Kopien wegzuoptimieren, wenn die Kopie implizit (über Parameter oder Rückgabewert) erfolgt.

Das Verhalten von rüdigers Funktion ist analog zum operator+ bei std::string .

ergänzend noch folgender Artikel
http://cpp-next.com/archive/2009/08/want-speed-pass-by-value/

operator+ finde ich eigentlich unpassend, da a+b != b+a (ok ist bei strings auch so. Aber da finde ich + auch unpassend)

template<typename T, class Alloc>
vector<T, Alloc>
operator+(vector<T, Alloc> lhs, vector<T, Alloc> const &rhs)
{
  lhs.reserve(lhs.size() + rhs.size());
  lhs.insert(lhs.end(), rhs.begin(), rhs.end());
  return lhs;
}

Ich denke nicht, dass reserve notwendig ist. Ich würde mal davon ausgehen, dass, falls insert RandomAccess-Iteratoren bekommt, es selbst schlau genug ist, entsprechend Platz zu machen. Das geht ja eigentlich recht einfach über iterator_traits<Iter>::iterator_category und Tag-Dispatching. Gut, garantiert wird dies wahrscheinlich nicht, aber es macht IMHO eine gute StdLib-Implementierung aus. (Ich hab's in diesem Fall nicht wirklich getestet, aber ich weiß, dass zB in libstdc++ derartige Optimierungen en masse enthalten sind. std::copy kann z.B. u.U. auch zu einem memmove reduziert werden).

Bzgl Performanz/Optimierung geht sogar noch einen Tucken besser:

template<typename T, class Alloc>
vector<T, Alloc>
operator+(vector<T, Alloc> lhs, vector<T, Alloc> const &rhs)
{
  vector<T,Alloc> result;
  result.swap(lhs);
  result.insert(result.end(), rhs.begin(), rhs.end());
  return result;  // NRVO möglich
}

Jedoch werden die Elemente bei der Zuweisung in c = a+b; noch unnötig kopiert. Da man vector<> nicht verändern kann, geht das meines Wissens nach auch nicht anders -- es sei denn, man arbeitet im C++0x Modus. Dann findet natürlich kein unnötiges Kopieren statt, weil die Elemente von (a+b) einfach nach c "umziehen".

kk

Viel lieber wäre mir aber solch eine Lösung:

vector<int> z;
z = b + e + b;

Die unnötige Kopie, von der ich vorhin sprach, lässt sich aber auch so umgehen:

vector<int> z = b + e + b;

Tipp: Vermeide Definition mit Defaultinitialisierung + Zuweisung. Benutze gleich die richtige Initialisierung. Hier kann ein Compiler die unnötige temporäre Kopie, die sich aus (b+e+b) ergibt, wegoptimieren.

kk

also vektoren mit "+" aneinanderhängen ist doch sowieso schmarrn.
nicht umsonst nimmt man in java/c#/... einen string-builder statt dauernd strings mit "+" zusammenzuhängen.

Ich glaube nicht.
Man nimmt den Stringbuilder, weil er so toll wachsen kann wie ein std::vector oder std::string. Normale Strings können das nähmlich nicht.
Nur ist für viele Anfügungen der op+ nicht gut und der op+= ist besser.

Alternativ wäre es noch eine Möglichkeit das in einen namespace zu packen, aber ich denke, dass das nicht nötig ist.

Gilt der Operator dann nur in dem namespace oder kann man dann folgendes schreiben:

std::vector<int> A, B, X;
X = A std::+ B

drakon schrieb:

Alternativ wäre es noch eine Möglichkeit das in einen namespace zu packen, aber ich denke, dass das nicht nötig ist.

Gilt der Operator dann nur in dem namespace oder kann man dann folgendes schreiben:

std::vector<int> A, B, X;
X = A std::+ B

Weder noch. Man kann den operator nicht in std überladen, weils schlicht verboten ist, neue Definitionen in std zu packen. Templatespezialisierungen mal ausgenommen.
ns::+ funktioniert garnicht, das müsste man dann explizit schreiben als X = ns::operator+(A, B)
alternativ kann man den Operator in den jeweiligen Scope oder Namespace importieren per using-Direktive.

alternativ kann man den Operator in den jeweiligen Scope oder Namespace importieren per using-Direktive.

Das war meine Intention. Ich würde wahrscheinlich den namespace nehmen, wenn diese Überladung auch für andere Dateien von Interesse ist und die direkte Implementierung in die Quelldatei, wenn du das nur in einem File brauchst (weil da der namespace nicht viel bringt).

Man kann sich das auch alles sparen, und vernünftigerweise eine freie Funktion anstelle eines höchst fragwürdigen Operators verwenden.

Wenn ich jetzt nicht viel zu tun hätte, würde ich filisofisch werden, warum uns das nicht vorher eingefallen ist.

filisofisch

Wenn dann: filosofisch oder vielohsofisch