Arbeiten in Klasse, was mache ich hier falsch?



  • Moin Leute,
    Kann sich vlt jemand mal diesen Programm-Code angugen?

    #include <iostream> //Standard Input Output Stream
    
    using namespace std;
    
    class klasse
    	{
    	char feld [11][11] = {
    										   {' ','A','B','C','D','E','F','G','H','I','J'},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    								};
    		public:
    		void Show()
    		{
    			int i,j;
    			for(i=0;i<=11;i++)
    				{
    					for (j=0;j<=11;j++)
    						{
    							cout << feld[i][j] << endl;
    						}
    				}
    		}
    	};
    
    int main(int argc, char *argv[]) //Hauptprogramm
    
    	{
    		klasse klasse_1;
    		klasse_1.Show();
    
         return 0;
    
    	}
    

    was ist hier Falsch? 😕 mein Compiler (g++) spuckt volgende Fehler aus:

    blub2.cpp:15: error: a brace-enclosed initializer is not allowed here before ‘{’ token
    blub2.cpp:27: error: ISO C++ forbids initialization of member ‘feld’
    blub2.cpp:27: error: making ‘feld’ static
    blub2.cpp:27: error: invalid in-class initialization of static data member of non-integral type ‘char [11][11]’
    blub2.cpp: In member function ‘void klasse::Show()’:
    blub2.cpp:36: error: ‘feld’ was not declared in this scope
    

    mfg black Sheep007



  • Du kannst feld nicht direkt etwas zuweisen. Das mußte dann schon im Konstuktor erledigen.



  • Oder du machst dein Array statisch:

    class klasse
    {
    	static char feld [11][11];
    public:
    	void Show()
    	{
    		int i,j;
    		for(i=0;i<=11;i++)
    		{
    			for (j=0;j<=11;j++)
    			{
    				std::cout << feld[i][j] << std::endl;
    			}
    		}
    	}
    }; 
    
    char klasse::feld[11][11] = {
    	{' ','A','B','C','D','E','F','G','H','I','J'},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    };
    


  • for(i=0;i<=11;i++)
    

    0 1 2 3 4 5 6 7 8 9 10 11
    ...sind insgesamt 12 indices, und du hast ein 11x11 array. Hier wirds krachen.



  • Mhn was hat das denn mit den Konstuktoren auf sich?
    Fange gerade mit der OOP-Programmierung an 😃



  • Der Konstruktor einer Klasse wird immer aufgerufen, wenn eine Instanz der Klasse erzeugt wird. Dort kannst du dann Variablen initialisieren, etc...

    class foo
    {
    public:
        foo(); //Konstruktor (hat immer den Klassennamen)
    private:
        int i; //nur Deklaration der Variable
    };
    
    foo::foo()
    {
        i = 10; //hier kannste dann einen Wert zuweisen
                //kannst dir auch mal eine "Initialisierungsliste" angucken
    }
    


  • Hazzel schrieb:

    foo::foo()
    {
    i = 10; //hier kannste dann einen Wert zuweisen
    //kannst dir auch mal eine "Initialisierungsliste" angucken
    }
    [/cpp]

    aber dies kann ich nicht einfach auf ein Array übernehmen oder?
    Bei mir spuckt das Programm dann nur wilde Zeichen aus...

    klasse::klasse()
    	{
    			char feld [11][11]= {
    										   {' ','A','B','C','D','E','F','G','H','I','J'},
    											{'0',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'1',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'2',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'3',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'4',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'5',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'6',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'7',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'8',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    											{'9',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
    								};
    	}
    


  • so nicht nein. du deklarierst da eine neue variable. lass das char und das [11][11] mal weg, bin aber net sicher ob es dann geht. Wenn nicht musst du das feld einfach durchlaufen.



  • Naja ... mal mit dynamischer Größe:

    #if !defined(TEST_CLASS_H__INCLUDED)
    #define TEST_CLASS_H__INCLUDED
    
    class test_class
    {
    public:
    	test_class(const size_t&);
    	~test_class();
    
    public:
    	void	show();
    
    public:
    	void	set_item(const size_t&, const size_t&, const char&);
    	char	get_item(const size_t&, const size_t&);
    	void	set_std_values();
    
    private:
    	size_t	m_dimension;
    	char**	m_items;
    };
    
    #endif // TEST_CLASS_H__INCLUDED
    
    #include "test_class.h"
    
    test_class::test_class(const size_t& size) : m_dimension(size)
    {
    	m_items = new char*[size];
    	for (size_t y = 0; y < size; ++y)
    		m_items[y] = new char[size];
    }
    
    test_class::~test_class()
    {
    	for (size_t y = 0; y < m_dimension; ++y)
    		delete [] m_items[y];
    
    	delete [] m_items;
    }
    
    void test_class::show()
    {
    	for (size_t item = 0; item < m_dimension; ++item)
    		std::cout << m_items[item] << std::endl;
    }
    
    void test_class::set_item(const size_t& x, const size_t& y, const char& c)
    {
    	if (m_dimension <= x || m_dimension <= y)
    		return;
    
    	m_items[x][y] = c;
    }
    
    char test_class::get_item(const size_t& x, const size_t& y)
    {
    	return ((m_dimension <= x || m_dimension <= y) ? 0 : m_items[x][y]);
    }
    
    void test_class::set_std_values()
    {
    	for (size_t y = 0; y < m_dimension; ++y)
    		m_items[0][y] = static_cast<char>(y + 65);
    
    	for (size_t x = 1; x < m_dimension; ++x)
    	{
    		m_items[x][0] = static_cast<char>(x + 47);
    		for (size_t y = 1; y < m_dimension; ++y)
    			m_items[x][y] = 0;
    	}
    }
    
    int main()
    {
    	test_class inst(11);
    	inst.set_std_values();
    	inst.show();
    }
    

    😃



  • Habs mal überflogen aber so dürfts gehen

    [cpp]#include <iostream> //Standard Input Output Stream
    
    using namespace std;
    
    class klasse
        {
    
            public:
    	klasse()//Konstruktor
    	{
    	feld [0][0] = ' ';
    	feld [0][1] = 'A';
    	feld [0][2] = 'B';
    	feld [0][3] = 'C';
    	feld [0][4] = 'D';
    	feld [0][5] = 'E';
    	feld [0][6] = 'F';
    	feld [0][7] = 'G';
    	feld [0][8] = 'H';
    	feld [0][9] = 'I';
    	feld [0][10] = 'J';
    	for (int y=1;y<11;++y)
    	{
    		for (int x=0;x<11;++x)
    		{
    		feld [y] [x] = ' ';
    		}
    	}
    	}
    
            void Show()
            {
    
                for(i=0;i<11;i++)// Vorsicht!! nicht <=(kleinergleich) wenn du ein Feld [11] erstellst 
                    //geht dieses von [0 bis 10] und [11] liefert komische Werte
                    {
    
                        for (j=0;j<11;j++)//siehe drüber
                            {
                                cout << feld[i][j]; /*<< endl; besser runter!!"(soll ja wie ein Feld aussehen ein Feld sein ;))*/
                            }
    			cout << endl;
                    }
            }
    
    	private:
    //private Variablen der klasse
    	    char feld [11] [11]; 
                int i,j;
        };
    
    int main(int argc, char *argv[]) //Hauptprogramm
    
        {
            klasse klasse_1;//Konstruktoraufruf
            klasse_1.Show();
    
         return 0;
        }
    [/cpp]
    

    falls du auf Feld auserhalb der Klasse auch zugreifen willst, musst du es in public: reintun

    kaffee



  • cool 🙂 besten Dank
    klappt alles bestens

    mfg black Sheep



  • (D)Evil schrieb:

    #if !defined(TEST_CLASS_H__INCLUDED)
    

    Warum; wenn's doch

    #ifndef TEST_CLASS_H__INCLUDED
    

    gibt???
    Hast du's einfac so gelernt oder hat das irgentwelche Vorteile???


Log in to reply