ich bearbeite gerade meine alten Matrix/Vektorklassen, die ich mir für ein Spiel geschrieben hatte. Momentant sind das noch zwei verschiedene Klassen, ich bin mir allerdings nicht ganz sicher, ob ich sie noch "vereine". (Das gehört aber eigentlich nicht zur Frage.)
Also meine Matrixklasse sieht in etwa so aus:

template<typename T, unsigned N>
  struct BlockMatrix
  {
    // ...
  private:
    T data_[N][N];
  public:
    // ...
    // Bitte keine Hinweise auf size_t statt unsigned. ;)
    T* operator [] (unsigned index)
    {
      return data_[index];
    }
    T const* operator [] (unsigned index) const
    {
      return data_[index];
    }
    // ...
  };

Ich gebe hier also T* bei operator [] zurück, was mir so nicht gefällt. Eine Referenz auf einen Vektor zurückzugeben würde ich wesentlich angenehmer finden. Allerdings muss die Matrix eine .data() Methode haben, die auf sicher zusammenhängenden Speicher zeigt. (Um sie in einen Shader zu kopieren.)
Das bedeutet, dass ich nicht einfach einen GeometricVector<T, N> vectors_[N] verwenden kann, was natürlich perfekt wäre. (Nervt mich eh extrem, dass der Standard kein Mittel zur Paddingkontrolle gibt. -.-)
Ich könnte natürlich eine Vektorklasse schreiben, die einfach einen Pointer auf ihren Speicherbereich erhält. Wenn ich das dann allerdings zurückgeben würde (value), würde das komisches Verhalten nach sich ziehen:

auto v = matrix[0];
v.x() = 5; // Verändert Matrix, obwohl v keine Referenz ist.
           // So ein Verhalten ist aber natürlich völlig undurchsichtig.

operator [] muss also definitiv eine Referenz auf irgendetwas zurückgeben. Wenn ich also zusätzlich zu T[N][N] noch ein Array aus N Vektoren definiere, die jeweils einen Teil des Speichers "verwalten", und auf die ich dann Referenzen liefern kann, stellt sich ein neues Problem. Wie initialisiere ich die? Da die Größe nicht bekannt ist, kann man die Initialisierungsliste vergessen. Ok, also in einer Schleife im Konstruktor. Trotzdem, operator = ist ja schon besetzt, der macht eine tiefe Kopie. Also vielleicht über eine "setMemory()" Methode? Ja, das könnte wohl gehen, aber irgendwie scheint mir das Ganze mehr und mehr zusammengefrickelt, und ich wollte mal hören, ob hier jemand eine bessere Idee dazu hat.

Besten Dank im Voraus.

Edit: Mittlerweile bin ich fast gewillt, den operator [] ganz wegzulassen und nur einen operator (i, j) anzubieten.

struct A { int i; };

garantiert, dass gilt: (&A == &A.i).
Da die Vektorklasse ja auch nur einen Member hat, sollte so ein Cast also eigentlich möglich sein:
http://ideone.com/luBe4

#include <iostream>

struct V
{
  char foo[5];
  V()
  {}
  char& operator [] (unsigned index)
  {
    return foo[index];
  }
  void print()
  {
    std::cout << foo[2] << '\n';
  }
};

struct A
{
  char foo[5][5];
  V& operator [] (unsigned index)
  {
    return reinterpret_cast<V&>(foo[index]);
  }
};

int main()
{
  A a;
  a[2][2] = 'L';
  a[2].print();
}

Ich frage mich jetzt nur, ob dieser Cast auch von POD nach nicht POD definiert ist?

Edit: Mittlerweile bin ich fast gewillt, den operator [] ganz wegzulassen und nur einen operator (i, j) anzubieten.

Warum baust du dir keinen Proxy, der den operator(i,j) aufruft?

Der C++ Standard macht es nicht besser:

vector<bool> foo;
foo.push_back(false);
auto x = foo.front();
x = true;
cout << foo.front() << endl;

http://ideone.com/luHK0

Ich habe schon öfters mal darüber nachgedacht, ob bei so einer Stelle "operator auto" nicht ganz praktisch sein könnte:

class bool_ref
{
  vector<bool>& vec;
  int index;
public:
  …
  bool_ref& operator=(bool b) const { vec[index] = b; return *this; }

  bool operator auto() const { return vec[index]; }
  …
};

…

  auto x = …bool_ref-Ausdruck…;
  decltype(x) --> bool

@krümelkacker
Ein Grund mehr vector<bool> zu meiden.

Eine Referenz auf einen Vektor zurückzugeben würde ich wesentlich angenehmer finden.

Wäre bei

std::array< GeometricVector<T, N>, N >

das einzige Problem, dass GeometricVector<T, N> durch Padding grösser als N * sizeof(T) sein könnte, selbst wenn du intern ein Array T[N] verwenden würdest?

krümelkacker schrieb:

Ich habe schon öfters mal darüber nachgedacht, ob bei so einer Stelle "operator auto" nicht ganz praktisch sein könnte

Sowas könnte man vielleicht auch durch Traits bewerkstelligen:

template <typename T>
struct unproxified_type
{
    typedef T type;
};

template <>
struct unproxified_type< std::vector<bool>::reference >
{
	typedef bool type;
};

template <typename T>
typename unproxified_type<T>::type unproxify(T expr)
{
    return expr;
};

#define AUTO(var, expr) auto x = unproxify(expr)

Vielleicht noch mit std::forward . Gibt es eigentlich bereits eine Metafunktion, die einen Typen gleich r/lvalue-qualifiziert wie einen anderen?

metafn<double, int>::type        == double
metafn<double, int&&>::type      == double&&
metafn<double, const int&>::type == const double&

Das AUTO -Makro ist zwar nicht so hübsch wie die Zuweisung und muss dem Anwender bekannt sein, aber operator auto kommt mir ehrlich gesagt auch etwas speziell vor

Wäre bei

std::array< GeometricVector<T, N>, N >

das einzige Problem, dass GeometricVector<T, N> durch Padding grösser als N * sizeof(T) sein könnte, selbst wenn du intern ein Array T[N] verwenden würdest?

Jop.

camper schrieb:

Andernfalls wird dir
Matrix[0]=Matrix[1];

Sicher? Der operator = ist ja manuell geschrieben, oder darf da im Hintergrund noch mehr kopiert werden? (Ich denke mal du beziehst dich darauf, dass dann mehr kopiert werden könnte?)