C++: Array mit Konstanten?

[Michael N. (much)]

Hallo,

Ich versuche gerade meine C++ Kenntnisse aufzufrischen. Dabei bin ich 
auf folgendes Szenario gestoßen.

Ich habe eine Klasse A, von der im Hauptprogram zwischen 1 und 10 
Instanzen erzeugt werden. Klasse A enthält eine Memberfunktion, die auf 
Daten aus einer Tabelle zugreifen muss. Die Tabelle hat eine Größe von 
10 x 5 in der konstannte Parameter eingespeichert sind. (Die n-te 
Instanz von Klasse A soll die Parameter aus der n-ten Zeile der Tabelle 
entnehmen.)

Nun stellt sich mir die Frage wie, bzw. wo ich die Tabelle am besten 
deklariere und initialisiere! Meine bisherige Lösung sieht in etwa wie 
folgt aus. Meine Frage ist allerdings ob man das Problem irgendwie 
besser lösen kann.

static const double param[10][5] = {{1.0000, ... 0.0000},
                                    ...
                                    {1.0215, ... 0.2883}};

class A
{
public:
  A(void);
  double foo(unsigned int n);
};

double A::foo(unsigned int n)
{
  double x;
  double v[5];
  // v =  n-te Zeile von param
  // Berechne irgendetwas mit v.
  return x;
}

[Peter II (Gast)]

Ich würde der Klasse im Konstruktor die n-Zeile mitgeben.

[Di P. (drpepper)]

Wenn die Tabelle wirklich konstant ist, hast du schon einen geeigneten 
Ort gefunden, um sie abzulegen. Es macht ggf. Sinn, sie in eine eigene 
Headerdatei auszulagern und ihr einen Namespace zu geben.

Wenn sich die Werte nie ändern sollen, würde ich Peter II's Vorschlag 
wählen, und die Zeilennummer im Konstruktor übergeben und in einer 
Instanzvariable speichern.

A::A(unsigned int n) {
  myN = n;
}

void A::zugriffAufParam() {
  for(int i = 0; i < 5; ++i) {
    tuWasMit(param[myN][i]);
  }
}

Sollen sich die Werte nach der Zuordnung ändern können (z.B. für 
adaptive Filter) müssen sie eben in einen eigenen std::vector oder ein 
Array übertragen werden.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Hallo Michael,

Michael N. schrieb:
> Nun stellt sich mir die Frage wie, bzw. wo ich die Tabelle am besten
> deklariere und initialisiere!

wenn Du sie nur in einer Funktion benötigst, dann würde ich sie auch 
genau nur dort deklarieren. Das hat den Vorteil, dass Du einen knappen 
Namen wählen kannst und dass dieser Name dann auch ausserhalb der 
Funktion nicht sichtbar ist.

double A::foo(unsigned int n) const
{
  static const double param[10][5] = {{1.0000, ... 0.0000},
                                      ...
                                      {1.0215, ... 0.2883}};
  double x = ...;
  auto& const v = param[ n ];
  // v =  n-te Zeile von param
  // Berechne irgendetwas mit v.
  return x;
}

mfg Torsten

[Tom (Gast)]

Di P. schrieb:
> und die Zeilennummer im Konstruktor übergeben und in einer
> Instanzvariable speichern.

Ich würde etwas weiter gehen und eine const-Referenz auf die Zeile 
übergeben und als Instanzvariable speichern. Das würde die Abhängigkeit 
von A von der Tabelle deutlicher beschreiben als eine Zahl, die sich auf 
irgendwelche globalen Daten, die irgendwie auch irgendwo vorhanden sein 
müssen, bezieht.  Da die Referenz nur auf existierende Zeilen zeigen 
kann¹, würde sich auch das Problem der Bereichsüberprüfung für die 
Zeilennummer im Konstruktor lösen. Die wird bei näherer Betrachtung 
nämlich hässlich: Lässt man n=23 durchgehen und überlässt dem Aufrufer 
die Verantwortung? Exception aus dem Konstruktor? Still und leise auf 
legale Werte beschränken? Aufpassen und beten?



¹solange man sich nicht besondere Mühe gibt.

[Michael N. (much)]

Tom schrieb:
> Ich würde etwas weiter gehen und eine const-Referenz auf die Zeile
> übergeben und als Instanzvariable speichern. Das würde die Abhängigkeit
> von A von der Tabelle deutlicher beschreiben als eine Zahl, die sich auf
> irgendwelche globalen Daten, die irgendwie auch irgendwo vorhanden sein
> müssen, bezieht.

Irgendwie blicke ich nicht ganz durch wie ich die Zeile als 
const-referenz übergeben kann. Wie sieht denn die entsprechende 
deklaration aus?

Ich habs mit

A(const double (&ab[5]));

versucht, aber der Compiler meldet sich dann mit der Meldung:

error: declaration of ‘ab’ as array of references

[Mikro 7. (mikro77)]

const double array reference mit 5 werten:

f(const double (&array)[5]);

[Tom (Gast)]

Man könnte auch das, was bisher eine Arrayzeile ist, als eigenen 
Datentyp, nämlich einen Satz an Konfigurationsdaten, ansehen und das so 
hinschreiben.

[Michael N. (much)]

S. J. schrieb:
> const double array reference mit 5 werten:
> f(const double (&array)[5]);

Danke, so funktioniert es! Allerdings wird das von Tom beschrieben 
Problem:
Tom schrieb:
> Da die Referenz nur auf existierende Zeilen zeigen
> kann¹, würde sich auch das Problem der Bereichsüberprüfung für die
> Zeilennummer im Konstruktor lösen.
dadurch auch nicht wirklich gelöst.
Die Zeile

n = 12;
Stage(coeff::ai[n], coeff::bi[n])

kann im Programm so ausgefürht werden und liefert dann halt irgedwelchen 
Käse, da ai[12] und bi[12] eigentlich schon außerhalb des 
Speicherbereichs liegen.

[Mikro 7. (mikro77)]

Ich sehe bei der Aufgabenstellung nur einen Parameter: Ein integer 
zwischen 0 und 10. Ausgabewert ist ein double. Dafür muss man kein 
Klassengerüst bauen. Alles was es an public Funktionen braucht ist bspw:

double magic(unsigned);

Die (pseudo) Implementierung könnte dann folgendermaßen aussehen...

static double makeMagic(double x1, ... x5)
{
   ...do and return your magic stuff...
}

double magic(unsigned i)
{
  static std::array<double,10> const array = {{
     makeMagic(1.0000, ... 0.0000),
     ...
     makeMagic(1.0215, ... 0.2883) }} ;
  return array.at(i) ;
}

[Tom (Gast)]

Michael N. schrieb:
> dadurch auch nicht wirklich gelöst.

Du hast völlig recht, der Koffeinspiegel war zu weit abgesunken und ich 
habe Mist geschrieben. Das Gefummel mit std::get oben in hip.cpp würde 
das lösen, aber die Template-Hölle des modernen C++ ist nicht jedermans 
Sache...

[Sheeva P. (sheevaplug)]

Michael N. schrieb:
> Ich versuche gerade meine C++ Kenntnisse aufzufrischen. Dabei bin ich
> auf folgendes Szenario gestoßen.
>
> Ich habe eine Klasse A, von der im Hauptprogram zwischen 1 und 10
> Instanzen erzeugt werden. Klasse A enthält eine Memberfunktion, die auf
> Daten aus einer Tabelle zugreifen muss. Die Tabelle hat eine Größe von
> 10 x 5 in der konstannte Parameter eingespeichert sind. (Die n-te
> Instanz von Klasse A soll die Parameter aus der n-ten Zeile der Tabelle
> entnehmen.)
>
> Nun stellt sich mir die Frage wie, bzw. wo ich die Tabelle am besten
> deklariere und initialisiere! Meine bisherige Lösung sieht in etwa wie
> folgt aus. Meine Frage ist allerdings ob man das Problem irgendwie
> besser lösen kann.

Vielleicht mit statischen Membervariablen. Dann merkt sich Deine Klasse 
im Konstruktor, die wievielte Instanz von ihr erzeugt wurde, und greift 
auf die entsprechende Zeile des config-Arrays zu:

/**
 * compile:
 *   g++ -std=c++11 -Os -Wall -Wextra -Wpedantic -o array array.cpp
 */

#include <iostream>
#include <iomanip>
#include <array>
#include <vector>
#include <stdexcept>

std::array<std::array<double, 5>, 6> data =
    {{ {{0.0, 0.1, 0.2, 0.3, 0.4}},
       {{1.0, 1.1, 1.2, 1.3, 1.4}},
       {{2.0, 2.1, 2.2, 2.3, 2.4}},
       {{3.0, 3.1, 3.2, 3.3, 3.4}},
       {{4.0, 4.1, 4.2, 4.3, 4.4}},
       {{5.0, 5.1, 5.2, 5.3, 5.4}} }};

class A {
public:
    A(void) {
        instance = instanceCounter;
        instanceCounter++;
        if(instanceCounter > data.size()) {
            throw std::runtime_error("Gak!");
        }
    }
    double foo(unsigned int n = 0) {
        std::cout << "instance: " << instance << ", "
                  << "instanceCounter: " << instanceCounter << ", "
                  << "n: " << n << ", "
                  << std::setprecision(1)
                  << std::fixed
                  << "data[0:4]: " << data[instance][0]
                  << ", " << data[instance][1]
                  << ", " << data[instance][2]
                  << ", " << data[instance][3]
                  << ", " << data[instance][4]
                  << std::endl;
        return 0.0;
    }
private:
    unsigned int instance;
    static unsigned int instanceCounter;
};

unsigned int A::instanceCounter = 0;


int main(void) {

    std::vector<A*> vec;
    for(int i = 0; i < 6; ++i) {
        vec.push_back(new A());
    }

    for(auto& v: vec) {
        v->foo();
    }
    
    return 0;
}

Eine andere Lösung steckt die Konfigurationszeilen in eine deque, pop()t 
sich im Konstruktor ihre Konfigurationszeile vom Anfang der deque (und 
push()t sie gegebenenfalls in Destruktor wieder hinten dran):

/**
 * compile:
 *   g++ -std=c++11 -Os -Wall -Wextra -Wpedantic -o deque deque.cpp
 */

#include <iostream>
#include <iomanip>
#include <vector>
#include <array>
#include <deque>

std::deque< std::array<double, 5> > config =
    {{ {{0.0, 0.1, 0.2, 0.3, 0.4}},
       {{1.0, 1.1, 1.2, 1.3, 1.4}},
       {{2.0, 2.1, 2.2, 2.3, 2.4}},
       {{3.0, 3.1, 3.2, 3.3, 3.4}},
       {{4.0, 4.1, 4.2, 4.3, 4.4}},
       {{5.0, 5.1, 5.2, 5.3, 5.4}} }};

class A {
public:
    A(void) {
        if(config.size() == 0) {
            throw std::runtime_error("Gak!");
        }
        myData = config.front();
        config.pop_front();
    }
    ~A(void) {
        config.push_back(myData);
    }
    double foo(unsigned int n = 0) {
        std::cout << "in a.foo(): n: " << n << ", "
                  << std::setprecision(1)
                  << std::fixed
                  << "config[0:4]: " << myData[0] << ", "
                  << myData[1] << ", " << myData[2] << ", "
                  << myData[3] << ", " << myData[4]
                  << std::endl;
        return 0.0;
    }
private:
    std::array<double, 5> myData;
};


int main(void) {

    std::clog << "config has now " << config.size() << " elements." << std::endl;
    
    std::vector<A*> vec;
    for(int i = 0; i < 6; ++i) {
        vec.push_back(new A());
        // call foo() here...
        //vec.back()->foo(1);
    }

    std::clog << "config has now " << config.size() << " elements." << std::endl;

    // ...or call foo() there
    for(auto& v: vec) {
        v->foo(2);
    }

    std::clog << "config has now " << config.size() << " elements." << std::endl;

    // make sure to call destructor
    while(vec.size() > 0) {
        A* a = vec.back();
        vec.pop_back();
        delete(a);
    }

    std::clog << "config has now " << config.size() << " elements." << std::endl;

    return 0;
}