wie kann ich die Größe des Arrays in Zeile 9 dynamisch beim Erzeugen der Klasse mit dem Parameter Size initialisieren?

#include <iostream>

using namespace std;

class BufferClass
{
public:
    const int Size;
    unsigned char buffer[20];
    BufferClass(int tempSize) : Size(tempSize)
    {

    }
};

int main()
{
    BufferClass Buffer(20);
    cout << "Buffer Size: " << Buffer.Size << endl;
    return 0;
}

so geht es schonmal nicht:

#include <iostream>

using namespace std;

class BufferClass
{
public:
    const int Size;
    unsigned char buffer[Size];
    BufferClass(int tempSize) : Size(tempSize)
    {

    }
};

int main()
{
    BufferClass Buffer(20);
    cout << "Buffer Size: " << Buffer.Size << endl;
    return 0;
}

Ich möchte den Buffer auf einem AVR Microcontroller einsetzen, deshalb kommt die Verwendung von Vector schonmal nicht in Frage.

Die Größe soll auch schon zur Compilezeit feststehen, mein Codebeispiel war diesbezüglich also nicht ganz korrekt. Im folgenden Beispiel würde der Buffer zur Kompilezeit angelegt, richtig?

#include <iostream>

using namespace std;

class BufferClass
{
public:
    const int Size;
    unsigned char buffer[20];
    BufferClass(int tempSize) : Size(tempSize)
    {

    }
};

BufferClass Buffer(20);

int main()
{
    cout << "Buffer Size: " << Buffer.Size << endl;
    return 0;
}

Ich möchte den Buffer auf einem AVR Microcontroller einsetzen, deshalb kommt die Verwendung von Vector schonmal nicht in Frage.

Wieso genau?

Johannes T schrieb:

Die Größe soll auch schon zur Compilezeit feststehen, mein Codebeispiel war diesbezüglich also nicht ganz korrekt.

Dann nimm std::array oder, falls dein Compiler das nicht unterstützt, bau dir selber was äquivalentes:

template <typename T, size_t N>
class array
{
private:
  T data[N];

public:
  ...
};

template <typename T, size_t w, size_t h>
class surface
{
public:
  typedef T value_type;

  static const size_t width = w;
  static const size_t height = h;

private:
  T data[w * h];

public:
  const T& operator()(int x, int y) const { ... }
  T& operator()(int x, int y) { ... }
};

erstmal vielen dank für den Beispiel. Leider blicke ich noch nicht ganz durch, da sowohl Templates als auch Operatorüberladung völliges Neuland für mich sind.

Vielleicht hier nochmal etwas ausführlicher was ich machen möchte:

Ich will einen Framebuffer für verschiedene Grafik LCDs schreiben. Die Grafikroutinen, die bei allen gleich sind (z.B. String ausgeben), sollen in die Basisklasse GLCD. Die Klasse GLCD_SPI erbt von dieser Klasse und kümmert sich um die Kommunikation auf Hardwareebene. Mein einziges Problem ist jetzt noch, dass die Größe des Displays vom Konstruktoraufruf (Zeile 93) bis zur Arraygröße des Framebuffers durchgereicht wird. Zeile 1-24 ist meine aktuelle Version, die bis auf die "dynamische" Arraygröße funktioniert. Zeile 29-56 war ein Versuch, deinen Vorschlag umzusetzen, aber leider bisher noch ohne Erfolg. Geht das so überhaupt, wie ich mir das wünsche?

Vielleicht hast du noch ein paar Ideen und vielleicht könntest du noch kurz ein paar Worte über die beiden Zeilen mit dem überladenen Funktionsoperator (in deinem Code Z.14-15) verlieren. Haben die was mit der Initialisierung zu tun oder sind das set/get Funktionen?

Fragen über Fragen

/*
class Framebuffer
{
public:
    Framebuffer(int Size) : Size(Size)
    {
        return;
    }
	unsigned char getByte(int address)
    {
        return buffer[address];
    }
	bool setByte(int address, unsigned char value)
    {
        if(address<Size)
        {
            buffer[address] = value;
            return 0;
        }
    return 1;
    }

protected:
	int Size;
	unsigned char buffer[768];
};
*/

template <typename T = unsigned char, int tempSize = 0>
class Framebuffer
{
public:

    Framebuffer()
    {
        return;
    }
	unsigned char getByte(int address)
    {
        return buffer[address];
    }
	bool setByte(int address, unsigned char value)
    {
        if(address<Size)
        {
            buffer[address] = value;
            return 0;
        }
    return 1;
    }

protected:
	static const int Size = tempSize;
	T buffer[tempSize];

};

class GLCD
{
public:

	GLCD(int xSize, int ySize) : xSize(xSize), ySize(ySize), Buffer(xSize*ySize)
    {
        return;
    }
    void refresh();
	void String(int x, int y, char* string)
	{
        return;
	}

protected:
	int xSize;
	int ySize;
    Framebuffer Buffer;
};

class GLCD_SPI : public GLCD
{
public:
    GLCD_SPI(int xSize, int ySize) : GLCD(xSize,ySize)
    {
        return;
    }
    void refresh()
    {
        return;
    }
};

GLCD_SPI Display(96,64);

int main()
{
    // ....
}