Wie kann ich ein Array mit variabler Größe deklarieren (global)?

18

Ich möchte drei Arrays mit der gleichen Länge erstellen. Gemäß der Dokumentation müssen Arrays so definiert werden, int myArray[10];dass 10 durch eine bekannte Länge (eine andere Ganzzahl) ersetzt oder mit einem Array gefüllt werden kann {2, 3, 5, 6, 7}.

Allerdings, wenn ich einen Wert zu erklären versucht , int arrSize = 10;und dann ein Array auf dieser Größe basiert int myArray[arrSize];, erhalte ich die folgende: error: array bound is not an integer constant.

Gibt es eine Möglichkeit, Array-Größen variabel zu bestimmen, oder muss ich sie nur fest codieren? (Mir wurde beigebracht, dass Hardcoding schlecht ist und etwas, das man um jeden Preis vermeiden sollte.)

user3.1415927
quelle
Ich hatte ein ähnliches Problem und tat dies. Ich lerne auch, kann also nicht sagen, ob es eine gültige Lösung ist oder nicht, aber es hat funktioniert. Der folgende Teil des Codes, der Vektoren verwendet, hat mich einiges gekostet, um sie zu verstehen, und ich bin immer noch kein Experte: #include <string> #include <vector> #include <iostream> #include <algorithm> #include <string.h> using namespace std; int main () {Stringname; Zeichenfolge Adresse; String-Stadt; Zeichenfolge Land; String-Antwort; vector <vector <string >> personData; für (;;) {vector <string> myTempData; cout << "Name eingeben oder n zum Beenden" << endl; getline (cin, name); if (name == "n") {bre
Misterxp

Antworten:

22

Ihre Frage besteht eigentlich aus 2 Teilen.

1 / Wie kann ich die konstante Größe eines Arrays außerhalb des Arrays deklarieren?

Sie können entweder ein Makro verwenden

#define ARRAY_SIZE 10
...
int myArray[ARRAY_SIZE];

oder verwenden Sie eine Konstante

const int ARRAY_SIZE = 10;
...
int myArray[ARRAY_SIZE];

Wenn Sie das Array initialisiert haben und dessen Größe wissen müssen, können Sie Folgendes tun:

int myArray[] = {1, 2, 3, 4, 5};
const int ARRAY_SIZE = sizeof(myArray) / sizeof(int);

Die zweite sizeofbezieht sich auf den Typ jedes Elements Ihres Arrays int.

2 / Wie kann ich ein Array haben, dessen Größe dynamisch ist (dh erst zur Laufzeit bekannt ist)?

Dafür benötigen Sie eine dynamische Zuweisung, die auf Arduino funktioniert, aber im Allgemeinen nicht empfohlen wird, da dies dazu führen kann, dass der "Heap" fragmentiert wird.

Sie können (C Weg) tun:

// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source)
if (myArray != 0) {
    myArray = (int*) realloc(myArray, size * sizeof(int));
} else {
    myArray = (int*) malloc(size * sizeof(int));
}

Oder (C ++ Weg):

// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source or through other program logic)
if (myArray != 0) {
    delete [] myArray;
}
myArray = new int [size];

Weitere Informationen zu Problemen mit der Heap-Fragmentierung finden Sie in dieser Frage .

jfpoilpret
quelle
4
1) Auf ARRAY_SIZE = sizeof myArray / sizeof myArray[0];diese Weise können Sie den Typ von myArray ändern, ohne Fehler einzuführen. Aus dem gleichen Grund myArray = realloc(myArray, size * sizeof *myArray);. Übrigens ist das Casting des Rückgabewerts von malloc()oder auch realloc()unbrauchbar. 2) Das Prüfen auf myArray != 0in der C-Version ist sinnlos, wie realloc(NULL, sz)es äquivalent zu ist malloc(sz).
Edgar Bonet
const int ARRAY_SIZE = 10; int myArray [ARRAY_SIZE]; Glaubst du wirklich, dass es möglich ist? Dies würde einen variabel modifizierten Arrayfehler in C ergeben.
Arun Joe Cheriyan
@ArunCheriyan in CI weiß es nicht, aber in C ++ wird es perfekt kompiliert und ausgeführt. Da Arduino auf C ++ basiert, gibt es hier kein Problem.
jfpoilpret
0

Die Größe des Arrays muss zur Kompilierungszeit bekannt sein. Andernfalls sollten Sie den Speicher dynamisch zuweisen, indem Sie Folgendes verwenden:

char *chararray = malloc(sizeof(char)*x);

Dabei kann x (eine Ganzzahl) im Anwendungscode festgelegt werden (Sie können es aus eeprom laden, wenn Sie möchten, dass es eine dauerhafte, aber konfigurierbare Einstellung ist).


Wenn Sie jedoch nur einige Arrays derselben Größe deklarieren möchten, müssen Sie die Zahl nur als Konstante deklarieren:

const int arrsize = 10;
char array1[arrsize];
int array2[arrsize];

Ich denke, Dinge nicht hart zu codieren, ist nur dann sinnvoll, wenn Sie vernünftigerweise erwarten, dass der Benutzer die Einstellung irgendwann ändern möchte. Ich weiß nicht, ob das der Fall ist.

user2973
quelle
Das Codieren von Größen symbolisch statt wörtlich kann zwei Vorteile bieten: 1) Ein gut ausgewähltes Symbol dokumentiert oder schlägt zumindest den Grund für die Wahl vor; und 2) wenn andere Teile des Programms oder Moduls auf diese Wahl zugeschnitten werden müssen, kann ein Ausdruck, der dasselbe Symbol verwendet, dies automatisch machen, was die Wartung viel einfacher macht.
JRobert,
[Ein wenig vom Thema entfernt, aber] "Benutzer" ist mehrdeutig, da es eine von mehreren Personen bedeuten kann. Dies impliziert normalerweise den Endverbraucher, den Verbraucher des Endprodukts, sofern nicht anders angegeben. Es könnte der nächste Programmierer sein, der unmittelbar nächste Konsument Ihres Codes, der in der Tat ein Jahr oder länger Sie sein könnte (typisch nach meiner Erfahrung), nachdem ich die winzigen internen Details vergessen habe. Oder ein Systemdesigner, der Ihren Code als einsatzbereites Modul in sein Produkt einfügt. Ich vermute, Sie meinten den zweiten "Benutzer".
JRobert,
0

Wenn Sie die maximale Länge des Arrays kennen, initialisieren Sie das Array einfach mit dieser Länge und geben Sie dem Programm mit einer Ganzzahl an, wie viel des Arrays verwendet werden soll. Wenn es sich um den Unterschied zwischen 7,10 Byte handelt, verschwenden Sie nicht so viel Speicherplatz.

MichaelT
quelle
0

Ich weiß, dass ich hier etwas spät dran bin, aber theoretisch können reguläre Arrays nicht mit einer Variablen erstellt werden, um die Anzahl der Elemente zu definieren, die das Array haben wird, wie in:

int arrSize;
int myArray[arrSize];

Dies zeigt einen Fehler an, da das Programm beim Deklarieren des Arrays erwartet, dass der Wert zwischen den Klammern eine Konstante ist. Es gibt jedoch eine Möglichkeit, ein Array mit einer Variablen zu erstellen, die die Anzahl der Werte definiert, die dieses Array durch dynamische Speicherzuweisung für Wertemengen haben soll (diese Methode wurde nur mit eindimensionalen Arrays getestet und noch nicht getestet) mehrdimensional noch), und es geht in etwa so:

//First you create a pointer for the memory space to be separated for the set you're creating
int* myArray;
int arrSize; //Then you define the variable that will determine the amount of elements the array is going to have, you can give it a value whenever you want as long as this int is defined before the values in myArray are set 
myArray=(int*)calloc(arrSize,sizeof(int)) //Here, you establish that the instance myArray (whose memory space has already been separated through the creation of the pointer) will be separated into arrSize amount of elements of type int with a maximum memory value (in bytes) equal to the maximum available for the int type variables

Danach müssen Sie nur noch jedem Element, das in der Instanz myArray (die bereits ein Array ist) erstellt wurde, einen Wert zuweisen, wie bei einem normalen Array, das als myArray [arrSize] erstellt wurde.

NibboNSX
quelle