//in der tabelle.h-datei

public:

    int gesetzt(int stelle);

private:
    int wertetabelle[10];

//in der tabelle.cpp-datei

int wertetabelle[10]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

int tabelle::gesetzt(int stelle){
    return(tabelle::wertetabelle[stelle]);
}

Ich erzeuge die Klasse und nenne sie "test". Nun will ich mit folgendem Aufruf aus der anderen Klasse, in welcher ich "test" erzeugt habe diese Werte abfragen.

if(test->gesetzt(0)==0)

schon beim kompilieren bekomme ich die meldung, dass wertetabelle nicht benutzt wird.

Kann mir jemand sagen was ich falsch mache?

int wertetabelle[10]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

...definierst du eine neue Variable "wertetabelle", welche natürlich nix mit deiner Klasse zu tun hat.

MfG

#include "field.h"

Field::Field(QWidget *parent)
    : QLineEdit(parent)
{
    int wertetabelle[10]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
}

oder nicht?

So stimmts, wie du schon geschrieben hast:

//in der tabelle.h-datei 

public: 

    int gesetzt(int stelle); 

private: 
    int wertetabelle[10];

Warum legst du dann im Konstruktor nochmals eine "wertetabelle" an? Diese wird nach dem Konstruktoraufruf doch wieder zerstört...

Auch ein:

wertetabelle[0]=1;
wertetabelle[1]=1;
wertetabelle[2]=4;
wertetabelle[3]=7;
...

funktionierte nicht.

Was genau tust du und was genau ist der Fehler? Bitte nicht so zerstückelt erklären...

if(test->gesetzt(0)==0)

ist die einzige Abfrage welche funktioniert, klar steht ja überall nur eine 0 drinne. Wie bekomme ich es hin, dass der Konstruktor bereits das Array initialisiert?

ValueTableUser.h

#ifndef //bla
#define //bla
#include <vector>

std::vector<int> tableGenerator1(); //regel1 (standard)
std::vector<int> tableGenerator2(); //regel2

class ValueTableUser
{
public:
    ValueTableUser(); //erstellt tabelle mit standardregel
    ValueTableUser(const std::vector<int>& init_table); //erstellt tabelle aus gegebenem vector
    int getValue(size_t index){return m_ValueTable.at(index);} //zugriff auf wert <index>
    size_t size(){ return m_ValueTable.size();} //groesse der tabelle
private:
    std::vector<int> m_ValueTable;
};
#endif

ValueTableUser.cpp

ValueTableUser::ValueTableUser
    ()
    : m_ValueTable(tableGenerator1())
{ }

ValueTableUser::ValueTableUser
    (const std::vector<int>& init_table)
    : m_ValueTable(init_table)
{ }

std::vector<int> tableGenerator1( )
{
    std::vector<int> gen_vector(10, 1); 
    return gen_vector;
}

std::vector<int> tableGenerator2( )
{
    std::vector<int> gen_vector; 
    for(int n = 0; n < 20; ++n)
    {
        gen_vector.push_back(n);
    }
    return gen_vector;
}

main.cpp

#include <iostream>
#include "ValueTableUser.h"

int main()
{

    //standardtabelle benutzen
    ValueTableUser user;
    //selbst erzeugte tabelle benutzen
    ValueTableUser user2(tableGenerator2());

    //testen
    for(size_t n = 0; n < user.size(); ++n)
    {
        std::cout << user.getValue(n) << '\n';
    }

    for(size_t n = 0; n < user2.size(); ++n)
    {
        std::cout << user2.getValue(n) << '\n';
    }

    return 0;
}

Mal eben so hingeschleudert. Keine Ahnung, obs hilft.

Danke für die Antworten.