custom - c++ operator[] overloading



C++[] Array-Operator mit mehreren Argumenten? (4)

Kann ich in C ++ einen Array-Operator definieren, der mehrere Argumente akzeptiert? Ich habe es so ausprobiert:

const T& operator[](const int i, const int j, const int k) const{ 
    return m_cells[k*m_resSqr+j*m_res+i];
}

T& operator[](const int i, const int j, const int k){ 
    return m_cells[k*m_resSqr+j*m_res+i];       
}

Aber ich bekomme diesen Fehler:

error C2804 binary operator '[' has too many parameters

https://ffff65535.com


Der Vollständigkeit halber gilt: Es gibt eine Möglichkeit, den Klammeroperator tatsächlich mit mehreren Argumenten zu verwenden, wenn es sich nicht um grundlegende Datentypen handelt, und zwar durch Überladen des Kommaoperators und nicht des Klammeroperators. Weitere Informationen zum Kommaüberladen finden Sie im folgenden Beitrag:

https://.com/a/18136340/5836981

Haftungsausschluss: Die Überladung des Komma-Operators ist meiner Meinung nach fehleranfällig und macht den Code dunkler und ist nur in exotischeren Fällen eine Überlegung wert. Ich habe diese Antwort hinzugefügt, weil ich in einem Code eine Instanz davon gefunden habe, und es dauerte eine Weile, bis ich herausfand, dass der Schlüssel nicht der Operator [] war (der nicht mit mehreren Argumenten überladen werden kann), sondern den Operator,.


Es gibt einen kleinen Trick, den Sie mit der in C ++ 11 verfügbaren einheitlichen Initialisierungssyntax machen können. Anstatt den Index direkt zu nehmen, nehmen Sie einen POD.

struct indices
{
  std::size_t i, j, k;
};

T& operator[](indices idx)
{
  return m_cells[idx.k * m_resSqr + idx.j * m_res + idx.i];
}

Und dann die neue Syntax verwenden:

my_array<int> arr;
// ...
arr[{1, 2, 3}] = 42;


N-dimensionale Arrays mit beliebigem Typ und Größe in C ++:

Diese Antwort ist inspiriert von der Antwort von Pavel Radzivilovsky, danke dafür. Es fiel mir schwer, die Implementierung zu realisieren, da es mein erster Versuch war, rekursive Vorlagen zu verwenden. Ich möchte gerne mitteilen, was ich so gemacht habe, dass andere es schneller verstehen können als ich.

Ich habe eine C ++ - Vorlagenklasse geschrieben, um ein n-dimensionales Array mit beliebigem Typ und Größe zu erstellen. Es muss mit dem Array-Typ und der Anzahl der Dimensionen instanziiert werden. Die Größe kann dynamisch geändert werden. Nachfolgend habe ich eine unvollständige (stripped) Arbeitsversion gegeben, wie man ein mehrdimensionales Array erstellt, auf das die Elemente durch aufeinanderfolgende Anwendung des Operators [] (z. B. array [x] [y] [z]) zugegriffen werden können. Diese Version kann nur Arrays der Dimension n> 1 verarbeiten. Die Hauptfunktion zeigt als Beispiel, wie ein 4-dimensionales Array von Ganzzahlen erstellt wird.

BEARBEITEN : Denken Sie daran, dass das folgende Beispiel für die Lesbarkeit minimal ist , da das Array nicht freigegeben wird und der Zugriff nicht auf Grenzen geprüft wird. Dies hinzuzufügen ist trivial und bleibt dem Programmierer überlassen.

#include <stdio.h>
#include <stdlib.h>

template <typename T, int N>
struct array {
    array<T,N>() : data(NULL), offset((int*) malloc(sizeof(int)*N)){}
    array<T,N>(T *data, int *offset) : data(data), offset(offset){}
    array<T,N-1> operator[](int i){return array<T,N-1>(&data[i*offset[N]], offset);}
    bool resize(int *size){
        offset[N-1] = 1;
        int total_size = size[N-1];
        for(int i = N-2; i >= 0; i--){
            total_size *= size[i];
            offset[i] = offset[i+1]*size[i+1];
        }
        return (data = (T*) realloc (data, total_size*sizeof(T)));
    }
    T *data;
    int *offset;
};

template <typename T>
struct array<T,1>{
    array<T,1>(T *data, int *offset) : data(data){}
    T& operator[](int i){return data[i];}
    T *data;
};

int main () {
    array<int, 4> a;

    // create array with dimensions [1][3][3][7]
    int size[4] = { 1, 3, 3, 7 };
    a.resize(size);               

    a[0][1][2][3] = 123;

    return 0;
}

Genießen.





operator-keyword