#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

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'},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
	{' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
};

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.

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
}

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',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
								};
	}

#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();
}

[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

mfg black Sheep

#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???