kann kein Array zuweisen

[Anfänger (Gast)]

Ich hab eine Fifo-Klasse und muss das Array definieren. Ich bekomme das 
leider nicht hin. Beim Initialisieren vom Fifo möchte ich festlegen, wie 
groß der Fifo(Array) sein soll, weil ich welche mit unterschiedlichen 
Größen habe. Den Größenparameter übergebe ich im Konstruktor.

Ich muss das Array aber auch vorher im Header definieren, damit ich es 
anderswo einbinden kann.

Wie krieg ich das hin mit unterschiedlichen Initialwerten? Oder muss ich 
mit Konstanten arbeiten und dann z.B. fifo1.h/fifo1.cpp, 
fifo2.h/fifo2.cpp ... mit Festwerten in dem Header initialiseren? Das 
wäre ja ziemlich umständlich.


Headerdatei:

#ifndef FIFO_H
#define FIFO_H

#include "mbed.h"

// Headerdatei

class Fifo {
 public:
    uint8_t    Put  (uint16_t element);
    uint8_t    Get  (uint16_t  *element);
    void       Clear ();
    uint16_t   Anzahl ();
    uint8_t    RingBuffer(uint16_t size);
 private:
    uint16_t buffer_size;
    uint16_t buffer_mask;
    uint16_t data[buffer_size];   // <--- Hier ist der Fehler
    uint16_t read;
    uint16_t write;
};

#endif

cpp-Datei:

#include "fifo.h"

uint8_t Fifo::RingBuffer(uint16_t size) {
    if (size%2 != 0) { 
         return false;
    }
    else {
         read = 0;
         write = 0;
         buffer_size = size;
         buffer_mask = size-1;
         data = data[size];    // <--- Hier ist der Fehler
                               // wie muss ich das Array definieren?    
         return true;
    }
}
 
uint8_t Fifo::Put(uint16_t element) {
  uint8_t next = ((write + 1) & buffer_mask);
  if (read == next)
    return false;
  data[write] = element;
  // buffer.data[buffer.write & BUFFER_MASK] = element; // absolut Sicher
  write = next;
  return true;
}
 
uint8_t Fifo::Get(uint16_t *element) {
  if (read == write)
    return false;
  *element = data[read];
  read = (read+1) & buffer_mask;
  return true;
}

void Fifo::Clear()
{
    read = write = 0;
}

uint16_t Fifo::Anzahl()
{
    return (write - read) & (buffer_mask);
}

[Peter II (Gast)]

Anfänger schrieb:
> weil ich welche mit unterschiedlichen
> Größen habe. Den Größenparameter übergebe ich im Konstruktor.

entweder mit C++ Templates arbeiten oder mit malloc den Speicher im 
Konstruktor anfordern.

[Anfänger (Gast)]

meinst Du so?

#ifndef FIFO_H
#define FIFO_H

#include "mbed.h"

// Headerdatei

class Fifo {
 public:
    uint8_t    Put  (uint16_t element);
    uint8_t    Get  (uint16_t  *element);
    void       Clear ();
    uint16_t   Anzahl ();
    uint8_t    RingBuffer(uint16_t size);
 private:
    uint16_t buffer_size;
    uint16_t buffer_mask;
    uint16_t *data;
    uint16_t read;
    uint16_t write;
};

#endif

uint8_t Fifo::RingBuffer(uint16_t size) {
    if (size%2 != 0) { 
         return false;
    }
    else {
         read = 0;
         write = 0;
         buffer_size = size;
         buffer_mask = size-1;
         data = (uint16_t*) malloc (buffer_size);
         return true;
    }
}

[Peter II (Gast)]

Anfänger schrieb:
> meinst Du so?

ja, denke aber ans Freigeben vom Speicher und das der Kopierkonstruktor 
und der Zuweisungsoperator jetzt für deine Klasse nicht mehr sinnvoll 
arbeiten.

[Karl H. (kbuchegg)]

und anstelle von malloc benutzt du natürlich new!


Es gäbe noch eine dritte Variante.
In der stellt man sich auf den Standpunkt, dass gar nicht die FiFo 
Klasse das Array bereitstellen muss, sondern derjenige, der ein FiFo 
Objekt erzeugt dafür zuständig ist. Im Konstuktor muss man dann 
mitgeben, welches Array zu benutzen ist und dessen Länge. Das Objekt 
merkt sich dann einen Pointer auf dieses Array.

Ist nicht unbedingt schön und geht auch ein wenig am OOP Prinzip vorbei.

[Karl H. (kbuchegg)]

>

> uint8_t Fifo::RingBuffer(uint16_t size) {
>

die Funktionalität dieser Funktion sollte besser der Konstruktor 
übernehmen.

[Peter II (Gast)]

Karl Heinz schrieb:
> und anstelle von malloc benutzt du natürlich new!

was ist das gegenstück zu realloc?

[Karl H. (kbuchegg)]

Peter II schrieb:
> Karl Heinz schrieb:
>> und anstelle von malloc benutzt du natürlich new!
>
> was ist das gegenstück zu realloc?

gibt es nicht.

Array wegwerfen und neu allokieren. Hat dann auch den Vorteil, dass 
entsprechende Konstruktoren bzw. Destruktoren aufgerufen werden, wenn es 
sich um ein Array aus einem Objekttyp handelt.

Allerdings: er wird in seinem Programm auf einem µC kein realloc 
brauchen. :-)

[Anfänger (Gast)]

Karl Heinz schrieb:
> Es gäbe noch eine dritte Variante.
> In der stellt man sich auf den Standpunkt, dass gar nicht die FiFo
> Klasse das Array bereitstellen muss, sondern derjenige, der ein FiFo
> Objekt erzeugt dafür zuständig ist. Im Konstuktor muss man dann
> mitgeben, welches Array zu benutzen ist und dessen Länge. Das Objekt
> merkt sich dann einen Pointer auf dieses Array.

Ich hab mich für diese Variable entschieden, weil der Fifo auf einem 
Mikrocontroller laufen soll und mit malloc und new bin ich mir nicht so 
sicher, ob das gut ist in nem uC. Deshalb hab ich mir jetzt das 
ausgedacht:

Jetzt krieg ich aber die Fehlermeldung:

No instance of constructor Fifo::Fifo matches the argument list
uint16_t fifo_array1[FIFO1_LENGTH];

Was bedeutet denn das? Übergebe ich nicht richtig die Parameter an den 
Konstruktor?

#include "mbed.h"
#include "fifo.h"

#define FIFO1_LENGTH 01024
#define FIFO2_LENGTH 16384

uint16_t fifo_array1[FIFO1_LENGTH];
uint16_t fifo_array2[FIFO2_LENGTH];

Fifo myfifo1(&fifo_array1, FIFO1_LENGTH);
Fifo myfifo2(&fifo_array2, FIFO2_LENGTH); 

int main() {



}

#include "fifo.h"

Fifo::Fifo(uint16_t *buff, uint16_t size) {
    if (size%2 != 0) { 
         // return false;
    }
    else {
         read = 0;
         write = 0;
         buffer_size = size;
         buffer_mask = size-1;
         buffer_ptr = buff;
         // return true;
    }
}
 
uint8_t Fifo::Put(uint16_t element) {
  uint8_t next = ((write + 1) & buffer_mask);
  if (read == next)
    return false;
  *(buffer_ptr+(sizeof(uint16_t)*write) ) = element;
  // buffer.data[buffer.write & BUFFER_MASK] = element; // absolut Sicher
  write = next;
  return true;
}
 
uint8_t Fifo::Get(uint16_t *element) {
  if (read == write)
    return false;
  *element = *(buffer_ptr+(sizeof(uint16_t)*read));
  read = (read+1) & buffer_mask;
  return true;
}

void Fifo::Clear()
{
    read = write = 0;
}

uint16_t Fifo::Anzahl()
{
    return (write - read) & (buffer_mask);
}

#ifndef FIFO_H
#define FIFO_H

#include "mbed.h"

// Headerdatei

class Fifo {
 public:
    Fifo(uint16_t *buff, uint16_t size);        // Konstruktor

    uint8_t    Put  (uint16_t element);
    uint8_t    Get  (uint16_t  *element);
    void       Clear ();
    uint16_t   Anzahl ();

 private:
    uint16_t buffer_size;
    uint16_t buffer_mask;
    uint16_t *buffer_ptr;
    uint16_t read;
    uint16_t write;
};

#endif

[Karl H. (kbuchegg)]

Anfänger schrieb:

> Was bedeutet denn das?

Es bedeutet, dass du dir schleunigst Literatur kaufen solltest.

class A
{
public:
  A( int* dataSpace, size_t len ) : dataSpace_( dataSpace ), len_( len ) {};

  void setElement( size_t index, int value )
  int  getElement( size_t index ) const;

protected:
  size_t len_;
  int*   dataSpace_;

private:
  A( const A& arg );             // not implemented by intention
  A operator=( const A& rhs);    // not implemented by intention
};


void A::setElement( size_t index, int value )
{
  if( index < len_ )
    dataSpace_[index] = value;
}

int A::getElement( size_t index ) const
{
  if( index < len_ )
    return_ dataSpace[index];

  return -1;
}

#define DATA_LEN 8

int main()
{
  int mySpace[DATA_LEN];
  A myData( mySpace, DATA_LEN );
  int i;

  for( i = 0; i < DATA_LEN; i++ )
    myData.setElement( i, 2*i );

  for( i = 0; i < DATA_LEN; i++ )
    printf( "%d %d\n", i, myData.getElement( i );
}

Noch einfacher gehts nicht. Was immer du an diesem Code nicht verstehst 
ist ein Hinweis darauf, dass dir absolute Grundlagen fehlen. Auch wenn 
in Desktop-C++ Pointer nicht mehr ganz so häufig gebraucht werden, ist 
die Array-Pointer Dualität und Pointerarithmetik nach wie vor 
unabdingbares Basiswissen. Speziell wenn man aufgrund 
Nebenbeschränkungen dynamische Speicherallokierung nicht benutzen 
will/kann und daher auch nicht die STL Containerklassen benutzen kann.

[gonso (Gast)]

Karl Heinz schrieb:
> Noch einfacher gehts nicht. Was immer du an diesem Code nicht verstehst
> ist ein Hinweis darauf, dass dir absolute Grundlagen fehlen.

Mag sein, aber ein Fifo ist das nicht und der TE will einen Fifo haben.

Hier fehlt ein Semikolon:

  void setElement( size_t index, int value )  ;

[Rufus Τ. F. (rufus)]

gonso schrieb:
> Mag sein, aber ein Fifo ist das nicht und der TE will einen Fifo haben.

Das will er in seinem zweiten parallelen Thread.

[Karl H. (kbuchegg)]

gonso schrieb:
> Karl Heinz schrieb:
>> Noch einfacher gehts nicht. Was immer du an diesem Code nicht verstehst
>> ist ein Hinweis darauf, dass dir absolute Grundlagen fehlen.
>
> Mag sein, aber ein Fifo ist das nicht und der TE will einen Fifo haben.

Schön.
Dann soll er einen schreiben.
Ich bin nicht sein persönlicher unentgelticher "Schreib mal Code für 
mich". Ich zeig ihm gerne das, was ihm syntaktisch fehlt, aber umsetzen 
muss er es alleine.


> Hier fehlt ein Semikolon:

Gratulation. Soll vorkommen, dass man kleinere Syntaxfehler macht, wenn 
man Code direkt hier eintippt.