Definieren Array-Größe in Bibliothek, ohne es für jede neue Verwendung zu ändern?

Question

Beispiel: Die Klasse (Bibliothek) verwendet ein Array der standardmäßigen festen Größe. Sagen wir 64 Bytes. Im Programm benötigen Sie jedoch eine größere Größe, beispielsweise 128 Byte. Was wäre der beste Ansatz, wenn Sie die Bibliothek nicht jedes Mal neu schreiben möchten?

Ich habe versucht, diese falschen Code, indem Sie demonstrieren (mit #ifndef#define):

// myClass.h ***************************************** 

#ifndef myClass_h 
#define myClass_h 

#ifndef EXAMLPE 
#define EXAMLPE 64 
#endif 

class myClass{ 
     ... 
    private: 
     byte myArray[EXAMLPE]; // Use EXAMLPE to allocate array 
} 

#endif 


// Program.ino *************************************** 

// Override the default value without modifying the library 
#define EXAMLPE 128 
#include "myClass.h" 
// this does not work because of different scope, says compiler 

EDIT: Ich möchte feste Größe Array machen, wie es einfach ist, und es wird als gute Praxis auf 2 kb RAM betrachtet Plattform

EDIT 2: Ich verstehe nicht die ganze Argumentation in den Kommentar und auch warum meine Frage nicht bewertet wird. Ich bin natürlich kein großartiger Programmierer, ich weiß nichts über Vektoren oder Vorlagen, und darum bitte ich um Hilfe.

Ich bin auf der Suche nach einer Methode, wie Sie feste Größe Array in der Bibliothek aus Hauptcode in der Kompilierzeit festlegen.

Und schließlich: Weiß jemand, warum ich EXAMPLE was not declared in this scope kompilieren erhalten Fehler, wenn ich #ifndef Beispiel löschen ... # endif Linien aus Header? Ist es nicht so, dass es unabhängig vom Umfang ist?

Answer 1

C++ unterstützt keine Laufzeitgrößen-Arrays. Wenn Sie also zur Kompilierungszeit nicht wissen, welche Speichergröße Sie benötigen, ist ein Array das falsche Werkzeug für den Job. Ich würde stattdessen vorschlagen, dass Ihr Objekt nur einen Zeiger enthält, und verwenden Sie dann neu, um den Datenblock basierend auf einem bestimmten Laufzeitwert dynamisch zuzuweisen.

Beachten Sie, dass der folgende Code nur zur Demonstration der oben genannten Idee dient und nicht getestet wurde und wahrscheinlich nicht kompiliert wird.

class myClass { 
private: 
    byte *myData; 
public: 
    myClass(std::size_t dataSize) : 
      myData(new byte[dataSize]) 
    {} 
    myClass(const myClass&) = delete; 
    myClass(myClass&&) = delete; 
    myClass& operator=(const myClass&) = delete; 
    myClass& operator=(myClass&&) = delete; 
    ~myClass() 
    { 
     delete[] myData; 
    } 
}; 

Wenn auf der anderen Seite, die Größe zum Zeitpunkt der Kompilierung bekannt ist, aber Sie nicht wollen, die Header-Datei jedes Mal, wenn Sie die Größe ändern bearbeiten müssen Sie stattdessen eine Template-Klasse verwenden könnten, erlauben diese Benutzer stellen Kompilierzeitparameter bereit, wenn sie die Klasse verwenden. Zum Beispiel:

template<size_t dataSize> 
class myClass { 
private: 
    byte myArray[dataSize]; 
}; 

Die Klasse kann dann mit einem benutzerdefinierten Format zum Zeitpunkt der Kompilierung bekannt wie folgt erstellt werden:

auto foo = myClass<128>(); 

Answer 2

Compile-Zeit

Wenn Ihre Größe bei der Kompilierung definiert ist Zeit, könnten Sie eine Vorlagenklasse mit der Größe als Vorlage Argument verwenden.

template<int EXAMPLE> 
class myClass{ 
     ... 
    private: 
     byte myArray[EXAMPLE]; 
}; 

oder Sie könnten den std::array Container verwenden.

vs. Laufzeit

jedoch feste Größe Arrays sind nicht sehr flexibel. Ich rate daher dringend, stattdessen vectors zu verwenden.Sie können nicht nur festlegen eine Standardgröße für Ihren Vektor, aber diese Größe angepasst werden kann, dynamisch, ohne dass Sie über die Speicherverwaltung zu kümmern, Kopierkonstruktoren, Zuweisungsoperator, etc ...

class myClass { 
    public: 
     myClass(int mysize=64) : myVector(mysize) {}  
    private: 
     std::vector<byte> myVector; // no size needed here 
}; 

Answer 3

Warum die Verwendung nicht ersetzen eines Arrays für einen Vektor und definieren Methoden, um die maximale Größe des Vektors zu manipulieren. So etwas wie:

#include <vector> 


myClass{ 

private: 
    vector<int> v; 
    int maxSize 
public: 
    myClass(int size){ 
     v.reSize(size); 
     maxSize = size; 

    } 
    void add(int byte){ 
     if(v.size()<maxSize){ 
      v.push_back 
     } 
    } 
} 

Answer 4

Die Arduino IDE einige Tricks macht, wenn die .ino-Dateien in einer einzigen CPP-Datei konvertieren

• erstellen Funktionsprototypen
• schließlich #include Nachbestellung
(?)

Dies könnte Ihre

#define EXAMLPE 128

Th verschieben Die Vorlage Lösung ist am besten für Arduino, denke ich. Vektoren und dynamische Mem-Nutzung ist sehr gefährlich mit nur 2kB RAM (auf einem UNO).