Statisches Array: Deklaration, Füllung, Verwendung. Eindimensionale Arrays Möglichkeiten zum Aufzählen von Array-Elementen c

Ein Array ist eine Datenstruktur, die als Gruppe von Zellen desselben Typs dargestellt wird, die unter einem einzigen Namen zusammengefasst sind. Arrays werden zur Verarbeitung großer Datenmengen desselben Typs verwendet. Der Name des Arrays ist das, was Zeiger sind, das erzähle ich Ihnen etwas später. Eine einzelne Datenzelle eines Arrays wird als Array-Element bezeichnet. Die Elemente eines Arrays können Daten jeglichen Typs sein. Arrays können eine oder mehrere Dimensionen haben. Abhängig von der Anzahl der Dimensionen werden Arrays in eindimensionale Arrays, zweidimensionale Arrays, dreidimensionale Arrays usw. bis hin zu einem n-dimensionalen Array unterteilt. In der Programmierung werden am häufigsten eindimensionale und zweidimensionale Arrays verwendet, daher werden wir nur diese Arrays betrachten.

Eindimensionale Arrays in C++

Ein eindimensionales Array ist ein Array mit einem Parameter, der die Anzahl der Elemente des eindimensionalen Arrays charakterisiert. Tatsächlich ist ein eindimensionales Array ein Array, das nur eine Zeile und n Spalten haben kann. Die Spalten in einem eindimensionalen Array sind die Elemente des Arrays. Abbildung 1 zeigt die Struktur eines ganzzahligen eindimensionalen Arrays A. Die Größe dieses Arrays beträgt 16 Zellen.

Abbildung 1 – Arrays in C++

Beachten Sie, dass der maximale Index eines eindimensionalen Arrays ist A ist 15, aber die Größe des Arrays beträgt 16 Zellen, da die Nummerierung der Array-Zellen immer bei 0 beginnt. Der Zellenindex ist eine nicht negative Ganzzahl, mit der Sie auf jede Zelle des Arrays zugreifen und beliebige Aktionen darauf ausführen können ( Zelle).

//Syntax zum Deklarieren eines eindimensionalen Arrays in C++: /*Datentyp*/ /*Name eines eindimensionalen Arrays*/; //ein Beispiel für die Deklaration eines eindimensionalen Arrays wie in Abbildung 1 dargestellt: int a;

wobei int eine ganze Zahl ist;

A ist der Name eines eindimensionalen Arrays;
16 ist die Größe eines eindimensionalen Arrays, 16 Zellen.

Direkt hinter dem Namen des Arrays stehen stets eckige Klammern, in denen die Größe des eindimensionalen Arrays angegeben wird; dadurch unterscheidet sich das Array von allen anderen Variablen.

//eine andere Möglichkeit, eindimensionale Arrays zu deklarieren int mas, a;

Zwei eindimensionale Arrays mas und a werden mit den Größen 10 bzw. 16 deklariert. Darüber hinaus haben bei dieser Deklarationsmethode alle Arrays denselben Datentyp, in unserem Fall int.

// Arrays können bei der Deklaration initialisiert werden: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // Initialisierung eines eindimensionalen Arrays

Die Initialisierung eines eindimensionalen Arrays erfolgt in geschweiften Klammern nach dem Vorzeichen gleicht, jedes Array-Element wird durch ein Komma vom vorherigen getrennt.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // Initialisierung des Arrays ohne Bestimmung seiner Größe.

In diesem Fall bestimmt der Compiler selbst die Größe des eindimensionalen Arrays. Die Größe eines Arrays kann nur bei der Initialisierung weggelassen werden; bei der normalen Deklaration eines Arrays muss die Größe des Arrays angegeben werden. Lassen Sie uns ein einfaches Programm zur Verarbeitung eines eindimensionalen Arrays entwickeln.

// array.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung. #include „stdafx.h“ #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// Code Code::Blocks

// Dev-C++-Code

// array.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung. #enthalten Verwenden des Namensraums std; int main(int argc, char* argv) ( cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

IN Zeilen 10 - 11 Es wurde ein ganzzahliges eindimensionales Array mit dem Namen array1 deklariert und initialisiert, dessen Größe 16 Zellen beträgt, d. h. ein solches Array kann 16 Zahlen speichern. Jede Array-Verarbeitung ist nur in Verbindung mit Schleifen möglich. Welche Schleife Sie für die Verarbeitung des Arrays wählen, liegt bei Ihnen. Aber für diese Aufgabe ist es am besten geeignet. Wir werden die Zählervariable counter verwenden, um auf die Elemente des eindimensionalen Arrays array1 zuzugreifen. Die Bedingung für die Fortsetzung der for-Schleife enthält ein striktes Ungleichheitszeichen, da es im eindimensionalen Array array1 keinen sechzehnten Index gibt. Und da die Nummerierung der Zellen bei Null beginnt, gibt es 16 Elemente im Array. Im Körper der for-Schleife gibt der cout-Operator die Elemente eines eindimensionalen Arrays aus (siehe Abbildung 2).

Obrabotka massiva indexiert Element massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Um fortzufahren, drücken Sie eine beliebige Taste. . .

Abbildung 2 – Arrays in C++

Lassen Sie uns ein weiteres Programm zur Verarbeitung eines eindimensionalen Arrays in C++ entwickeln. Das Programm muss nacheinander zehn eingegebene Zahlen von der Tastatur lesen. Alle eingegebenen Zahlen werden summiert und das Ergebnis auf dem Bildschirm angezeigt.

// array_sum.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung. #include „stdafx.h“ #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// Code Code::Blocks

// Dev-C++-Code

// array_sum.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung. #enthalten Verwenden des Namensraums std; int main(int argc, char* argv) ( int array1; // Deklariere ein Integer-Array cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>array1; // über die Tastatur eingegebene Zahlen lesen cout<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Vor der Verarbeitung eines Arrays muss dieses deklariert werden und die Größe eines eindimensionalen Arrays beträgt 10, da dies durch die Bedingung der Aufgabe vorgegeben ist. In der Summenvariablen akkumulieren wir die Summe der Elemente eines eindimensionalen Arrays. Die erste for-Schleife füllt das deklarierte eindimensionale Array mit über die Tastatur eingegebenen Zahlen. Zeilen 12 - 13. Die Zählervariable wird verwendet, um sequentiell auf die Elemente des eindimensionalen Arrays array1 zuzugreifen, beginnend mit Index 0 und bis einschließlich 9. Die zweite for-Schleife zeigt die Elemente des Arrays an. Zeilen 15 - 16. Die dritte for-Schleife liest nacheinander die Elemente eines eindimensionalen Arrays und summiert sie. Die Summe wird in der Summenvariablen akkumuliert. Zeilen 17 - 18. Das Ergebnis des Programms ist in Abbildung 3 dargestellt.

Geben Sie massive Elemente ein: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Um fortzufahren, drücken Sie eine beliebige Taste. . .

Abbildung 3 – Arrays in C++

Zuerst wurden alle 10 Zahlen nacheinander eingegeben, danach wurde ein eindimensionales Array angezeigt und die Summe der Zahlen im Array gedruckt.

Zweidimensionale Arrays in C++

Bisher haben wir eindimensionale Arrays betrachtet, auf die man sich nicht immer beschränken kann. Nehmen wir an, Sie müssen einige Daten aus einer Tabelle verarbeiten. Eine Tabelle hat zwei Merkmale: die Anzahl der Zeilen und die Anzahl der Spalten. Auch in einem zweidimensionalen Array gibt es neben der Anzahl der Array-Elemente Eigenschaften wie die Anzahl der Zeilen und die Anzahl der Spalten eines zweidimensionalen Arrays. Das heißt, optisch gesehen ist ein zweidimensionales Array eine reguläre Tabelle mit Zeilen und Spalten. Tatsächlich ist ein zweidimensionales Array ein eindimensionales Array aus eindimensionalen Arrays. Die Struktur eines zweidimensionalen Arrays mit der Bezeichnung a und der Größe m mal n ist unten dargestellt (siehe Abbildung 4).

Abbildung 4 – Arrays in C++

wobei m die Anzahl der Zeilen eines zweidimensionalen Arrays ist;
n ist die Anzahl der Spalten eines zweidimensionalen Arrays;
m * n – Anzahl der Array-Elemente.

// Syntax zum Deklarieren eines zweidimensionalen Arrays /*Datentyp*/ /*Array-Name*/;

Bei der Deklaration eines zweidimensionalen Arrays sowie bei der Deklaration eines eindimensionalen Arrays müssen Sie zunächst Folgendes angeben:

Datentyp;
Array-Name.

Danach geben die ersten eckigen Klammern die Anzahl der Zeilen des zweidimensionalen Arrays und die zweiten eckigen Klammern die Anzahl der Spalten des zweidimensionalen Arrays an. Ein zweidimensionales Array wird optisch von einem eindimensionalen Array durch ein zweites Paar eckiger Klammern unterschieden. Schauen wir uns ein Beispiel für die Deklaration eines zweidimensionalen Arrays an. Nehmen wir an, wir müssen ein zweidimensionales Array mit einer Anzahl von 15 Elementen deklarieren. In diesem Fall kann ein zweidimensionales Array drei Zeilen und fünf Spalten oder fünf Zeilen und drei Spalten haben.

// Beispieldeklaration eines zweidimensionalen Arrays: int a;

a ist der Name des Integer-Arrays
Die Zahl in den ersten eckigen Klammern gibt die Anzahl der Zeilen des zweidimensionalen Arrays an, in diesem Fall sind es 5;
Die Zahl in der zweiten eckigen Klammer gibt die Anzahl der Spalten des zweidimensionalen Arrays an, in diesem Fall sind es 3.

// Initialisierung eines zweidimensionalen Arrays: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Dieses Array besteht aus 5 Zeilen und 3 Spalten. Nach dem Zuweisungszeichen werden allgemeine geschweifte Klammern gesetzt, innerhalb derer so viele geschweifte Klammerpaare stehen, wie Zeilen in einem zweidimensionalen Array vorhanden sein sollten, und diese Klammern werden durch Kommas getrennt. Schreiben Sie in jedes Paar geschweifter Klammern die durch Kommas getrennten Elemente eines zweidimensionalen Arrays. In allen geschweiften Klammern muss die Anzahl der Elemente gleich sein. Da das Array fünf Zeilen enthält, gibt es auch fünf innere Klammerpaare. In die inneren Klammern werden drei Elemente geschrieben, da die Anzahl der Spalten drei beträgt. Grafisch sieht unser Array wie eine zweidimensionale Tabelle aus (siehe Abbildung 5).

Abbildung 5 – Arrays in C++

In jeder Zelle eines zweidimensionalen Arrays A Der Wert wird angezeigt, die Adresse dieser Zelle wird in der unteren rechten Ecke angezeigt. Die Zellenadresse eines zweidimensionalen Arrays besteht aus dem Array-Namen, der Zeilennummer und der Spaltennummer.

Lassen Sie uns ein einfaches Programm zur Verarbeitung eines zweidimensionalen Arrays namens „Labyrinth“ entwickeln. Das Labyrinth muss auf der Grundlage einer zweidimensionalen Anordnung aufgebaut sein. Die Größe des Labyrinths wählen wir nach eigenem Ermessen.

// array2.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung. #include „stdafx.h“ #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) sonst cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// Code Code::Blocks

// Dev-C++-Code

// array2.cpp: Definiert den Einstiegspunkt für die Konsolenanwendung. #enthalten Verwenden des Namensraums std; int main(int argc, char* argv) ( // 1-bedingt „Wände des Labyrinths“ // 2-“richtiger Pfad, Verlassen des Labyrinths“ // 0-“falscher Pfad“ int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // Initialisierung eines zweidimensionalen Arrays ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0 ,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2 ,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,) ); // zwei Schleifen – intern und extern, die auf jedes Element des Arrays zugreifen for (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) sonst cout<< " "; // вывести два пробела cout << endl; } return 0; }

Der richtige und der falsche Pfad könnten durch dieselbe Zahl gekennzeichnet werden, zum Beispiel Null, der Klarheit halber wird der richtige Pfad jedoch durch die Zahl 2 gekennzeichnet. Das Array wurde nur zur Vereinfachung des Programms manuell initialisiert. Da das Programm ein zweidimensionales Array verarbeitet, sind zwei Schleifen erforderlich, um zwischen Elementen des zweidimensionalen Arrays zu wechseln. Die erste for-Schleife wechselt zwischen Zeilen eines zweidimensionalen Arrays. Da ein zweidimensionales Array 33 Zeilen enthält, wird die Zählervariable i von 0 auf 33 erhöht. Zeile 46. Innerhalb der ersten Schleife befindet sich eine for-Schleife, die die Zeilenelemente eines zweidimensionalen Arrays durchläuft. Im Hauptteil der zweiten for-Schleife wird eine Konvertierungsoperation für einen unären Datentyp ausgeführt – static_cast<>() , wodurch die Zeichennummer 176 gedruckt wird. Der Datentyp-Konvertierungsvorgang wird dupliziert, um die Breite des Labyrinths zu vergrößern. Das Ergebnis des Programms (siehe Abbildung 6).

Abbildung 6 – Arrays in C++

Arrays

Array ist eine Sammlung von Variablen desselben Typs mit einem gemeinsamen Namen, der auf sie verweist. In C# können Arrays entweder eindimensional oder mehrdimensional sein. Arrays dienen einer Vielzahl von Zwecken, da sie eine praktische Möglichkeit zum Gruppieren verwandter Variablen bieten.

Sie können Arrays in C# auf die gleiche Weise verwenden wie in anderen Programmiersprachen. Sie haben jedoch eine Besonderheit: Sie werden als Objekte implementiert.

Die Verwendung eines Arrays in einem Programm erfordert ein zweistufiges Verfahren, da C# Arrays als Objekte implementiert. Zuerst müssen Sie eine Variable deklarieren, die auf das Array zugreifen kann. Und zweitens müssen Sie mit dem neuen Operator eine Instanz des Arrays erstellen.

Verwenden des Systems; mit System.Collections.Generic; mit System.Linq; Verwenden von System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Array deklarieren int myArr = new int; // Jedes Element des Arrays manuell initialisieren myArr = 100; myArr = 23; myArr = 25; myArr = 31; myArr = 1 ; foreach (int i in myArr) Console.WriteLine(i); Console.ReadLine(); ) ) )

Beachten Sie, dass, wenn ein Array nur deklariert, aber nicht explizit initialisiert wird, jedes Element auf den Standardwert für den entsprechenden Datentyp gesetzt wird (z. B. werden Elemente eines Arrays vom Typ „bool“ auf „false“ gesetzt und Elemente eines Array vom Typ int wird auf 0 gesetzt).

Initialisieren eines Arrays

Zusätzlich zum elementweisen Füllen des Arrays (wie im vorherigen Beispiel gezeigt) können Sie es auch mithilfe einer speziellen Array-Initialisierungssyntax füllen. Dazu müssen Sie die im Array enthaltenen Elemente in geschweiften Klammern ( ) auflisten. Diese Syntax ist nützlich, wenn Sie ein Array bekannter Größe erstellen und seine Anfangswerte schnell festlegen müssen:

// Syntax zum Initialisieren eines Arrays mit // dem Schlüsselwort new int myArr = new int (10,20,30,40,50); // Syntax zum Initialisieren eines Arrays ohne // Verwendung eines Schlüsselworts new string info = ( "Last Name", "First Name", "Patronymic" ); // Verwenden Sie das neue Schlüsselwort und die gewünschte Größe char symbol = new char ( "X", "Y", "Z", "M" );

Beachten Sie, dass Sie bei Verwendung der Syntax für geschweifte Klammern nicht die Größe des Arrays angeben müssen (wie bei der Erstellung der Variablen myArr zu sehen), da die Größe automatisch basierend auf der Anzahl der Elemente innerhalb der geschweiften Klammern berechnet wird. Verwenden Sie außerdem das Schlüsselwort neu optional (wie beim Erstellen eines Info-Arrays).

Mit dem Schlüsselwort var können Sie eine Variable so definieren, dass der zugrunde liegende Typ vom Compiler abgeleitet wird. Auf ähnliche Weise können Sie auch implizit typisierte lokale Arrays definieren. Mit diesem Ansatz können Sie eine neue Array-Variable definieren, ohne den Typ der im Array enthaltenen Elemente anzugeben. Schauen wir uns ein Beispiel an:

Verwenden des Systems; mit System.Collections.Generic; mit System.Linq; Verwenden von System.Text; Namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( var arr1 = new ( 1, 2, 3 ); Console.WriteLine("Array type arr1 is (0)",arr1.GetType()); var arr2 = new ("One", "Two", "Three" ); Console.WriteLine("Array type arr2 - (0)",arr2.GetType()); Console.ReadLine(); ) ) )

Natürlich müssen die in der Array-Initialisierungsliste angegebenen Elemente genau wie beim Erstellen eines Arrays mit expliziter C#-Syntax denselben zugrunde liegenden Typ haben (d. h. sie müssen alle int, string oder MyCar sein).

Definieren eines Arrays von Objekten

In den meisten Fällen wird beim Definieren eines Arrays der Typ des im Array enthaltenen Elements explizit angegeben. Obwohl dies auf den ersten Blick ziemlich einfach erscheint, gibt es ein wichtiges Merkmal. Das Herzstück jedes Typs im .NET-Typsystem (einschließlich grundlegender Datentypen) ist letztendlich eine Basisklasse, System.Object. Das Ergebnis ist, dass, wenn Sie ein Array von Objekten definieren, die darin enthaltenen Elemente alles sein können:

Verwenden des Systems; mit System.Collections.Generic; mit System.Linq; Verwenden von System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( // Ein Array von Objekten deklarieren und initialisieren object arrByObject = ( true, 10, "Hello", 13.7m ); // Geben Sie den Typ jedes Array-Mitglieds an die aus console foreach (Objekt me in arrByObject) Console.WriteLine("Type (0) - (1)",me,me.GetType()); Console.ReadLine(); ) ) )

Nehmen wir an, wir müssen mit einer großen Datenmenge desselben Typs arbeiten. Wir haben zum Beispiel tausend Messungen der Koordinaten eines Pendels mit einem bestimmten Zeitschritt. Das Erstellen von 1000 Variablen zum Speichern aller Werte ist sehr ... umständlich. Stattdessen können viele Daten desselben Typs unter einem Namen zusammengefasst werden und auf jedes spezifische Element kann über seine Seriennummer zugegriffen werden.
Ein Array in C ist wie folgt definiert
<тип> <имя массива>[<размер>];
Zum Beispiel,
int a;
Wir erhalten ein Array mit dem Namen A, das einhundert Elemente des Typs enthält int. Wie bei Variablen enthält das Array Müll.
Um Zugriff auf das erste Element zu erhalten, schreiben Sie dessen Nummer (Index) in eckige Klammern. Zum Beispiel

#enthalten #enthalten void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

Das erste Element hat die Indexnummer 0. Es ist wichtig zu verstehen, warum. Im Folgenden stellen wir den Computerspeicher als Band dar. Der Array-Name ist ein Zeiger auf die Speicheradresse, an der sich die Array-Elemente befinden.

Reis. 1 Das Array speichert die Adresse des ersten Elements. Der Index des i-Elements ist eine Verschiebung von i*sizeof(type) Bytes vom Anfang an

Der Array-Index gibt an, wie viele Bytes vom Anfang des Arrays verschoben werden müssen, um auf das gewünschte Element zuzugreifen. Wenn beispielsweise das Array A Typ hat int, dann bedeutet A, dass wir 10*sizeof(int) Bytes relativ zum Anfang verschoben haben. Das erste Element steht ganz am Anfang und hat einen Offset von 0*sizeof(int) .
In C speichert ein Array seine Größe nicht und überprüft den Array-Index nicht auf Richtigkeit. Dies bedeutet, dass Sie das Array verlassen und auf Speicher zugreifen können, der weiter als das letzte Element des Arrays (oder näher) liegt.

Erstinitialisierung des Arrays.

Schreiben wir ein einfaches Programm. Lassen Sie uns ein Array erstellen und dann sein maximales Element ermitteln.

#enthalten #enthalten void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); unsigned i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Schauen wir uns ein Beispiel an. Wir erstellen zuerst das Array und initialisieren es bei der Erstellung. Danach weisen wir dem maximal gefundenen Element den Wert des ersten Elements des Arrays zu.

Max = a;

Dann gehen wir das Array durch. Da wir uns das erste Element bereits angesehen haben (es hat den Index 1), macht es keinen Sinn, es noch einmal zu betrachten.
Gleiches Beispiel, nur gibt der Benutzer jetzt Werte ein

#enthalten #enthalten void main() ( int a; unsigned i; int max; printf("Geben Sie 10 Zahlen ein\n"); for (i = 0; i<10; i++) { printf("%d. ", i); scanf("%d", &a[i]); } max = a; for (i = 1; i<10; i++) { if (a[i] >max) ( max = a[i]; ) ) printf("maximales Element ist %d", max); getch(); )

Werden bei der Initialisierung weniger Werte angegeben als die Größe des Arrays, werden die restlichen Elemente mit Nullen aufgefüllt.

#enthalten #enthalten void main() ( int a = (1,2,3); unsigned i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Wenn Sie das gesamte Array mit Nullen füllen müssen, schreiben Sie

Int a = (0);

Sie müssen beispielsweise die Größe des Arrays nicht explizit angeben

Int a = (1, 2, 3);

Das Array hat die Größe 3

Arraygröße

Ein Array in C muss eine konstante Größe haben. Dies bedeutet, dass es beispielsweise unmöglich ist, den Benutzer nach einer Größe zu fragen und diese Größe dann auf ein Array festzulegen.

Printf("Geben Sie die Länge des Arrays ein"); scanf("%d", &length); ( float x; )

Das Erstellen dynamischer Arrays wird bei der Arbeit mit Zeigern und Speicher weiter erläutert.
In einigen Fällen können Sie die Größe des Arrays mithilfe der Funktion ermitteln Größe von.

#enthalten #enthalten void main() ( int A; //sizeof gibt die Größe des gesamten Arrays in Bytes zurück //Um die Anzahl der Elemente zu bestimmen, //dividiere die Größe des Arrays durch die Größe seines Elements int size = sizeof(A) / sizeof(int); printf("Größe des Arrays entspricht %d", size); getch(); )

Aber es ist unwahrscheinlich, dass dies nützlich ist. Wenn Sie ein Array als Argument an eine Funktion übergeben, wird ein Zeiger übergeben, sodass die Größe des Arrays nicht bekannt ist.
Statische Arrays sind nützlich, wenn die Anzahl der Elemente im Voraus bekannt ist. Sie ermöglichen einen schnellen, aber unsicheren Zugriff auf Elemente.

Array-Überlauf

Hoffen wir, dass Sie diesen Code haben

Int A; int i; für (i=0; i<=10; i++) { A[i] = 1; }

Hier ist eine Schleife für mit Fehler angegeben. In einigen älteren Compilerversionen kam es zu einer Schleife dieses Codes. Der Punkt ist, dass die Variable ich befand sich während der Kompilierung unmittelbar nach dem Array A. Wenn das Array die Grenzen überschreitet, wird der Zähler auf 1 gesetzt.
Arrays sind unsicher, da eine fehlerhafte Arbeit mit dem Index zum Zugriff auf einen beliebigen Teil des Speichers führen kann (Theoretisch. Moderne Compiler sorgen selbst dafür, dass Sie nicht in den Speicher eines anderen eintauchen).
Wenn Sie mit Arrays arbeiten, müssen Sie sicherstellen, dass der Zähler die Größe des Arrays nicht überschreitet und nicht negativ ist. Dazu mindestens

1. Verwenden Sie den Typ size_t für die Indizierung. Es schützt Sie vor negativen Werten und reicht immer für ein Array beliebiger Größe.
2. Denken Sie daran, dass das Array bei Null beginnt.
3. Das letzte Element des Arrays hat einen Index (Array-Größe ist 1)

Es gibt keine vollwertigen Möglichkeiten, um zu überprüfen, ob wir die Grenzen des Arrays überschritten haben oder nicht. Daher kennen wir entweder die Größe genau oder wir speichern sie in einer Variablen und lesen sie bei Bedarf aus.

Beispiele

Hier sind einige typische Beispiele für die Arbeit mit Arrays
1. Kehren Sie das Array um.

#enthalten #enthalten //Dies ist ein Makro. SIZE im Code wird durch 10u ersetzt #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i, j; // counters unsigned half; //Mitte des Arrays unsigned tmp; //temporäre Variable zum Austausch von Werten half = SIZE / 2; //Ein Zähler geht von links nach rechts, der andere von rechts nach links für (i = 0, j = GRÖSSE - 1; i< half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Hier ist ein Design, das Ihnen unbekannt ist

#define GRÖSSE 10u

Makro. Im gesamten Code ersetzt der Präprozessor automatisch alle Vorkommen von SIZE durch 10u.
2. Löschen eines vom Benutzer ausgewählten Elements.

#enthalten #enthalten #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //counter int index; //vom Benutzer eingegebener Index //Ausgabearray für (i = 0; i< SIZE; i++) { printf("(%d)=%d ", i, A[i]); } //Просим пользователя ввести валидный индекс while (1) { printf("\nEnter index of element to delete "); scanf("%d", &index); if (index >0 && Index< SIZE) { break; } } //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) { A[i] = A; } //Выводим результат for (i = 0; i < SIZE-1; i++) { printf("(%d)=%d ", i, A[i]); } getch(); }

In diesem Fall wird das Element natürlich nicht gelöscht. Das Array behält die gleiche Größe wie zuvor. Wir überschreiben einfach das zu löschende Element mit dem nächsten und geben SIZE-1-Elemente aus.
3. Der Benutzer gibt Werte in das Array ein. Drucken Sie anschließend alle von ihm eingegebenen Werte aus.
Lassen Sie den Benutzer eine endliche Anzahl von Elementen eingeben, beispielsweise 10. Dann ist im Voraus bekannt, dass es insgesamt nicht mehr als 10 verschiedene Werte geben wird. Jedes Mal, wenn der Benutzer eine Zahl eingibt, gehen wir das Array durch und überprüfen es ob eine solche Nummer eingegeben wurde.

#enthalten #enthalten #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //wie viele verschiedene Zahlen eingegeben werden. Mindestens eine. int input; int wasntFound; //kennzeichnen, dass die Die eingegebene Nummer wurde nicht gefunden //Geben Sie die erste Nummer ein. Sie wurde noch nicht gefunden. printf("0. "); scanf("%d", &A); for (i = 1; i< SIZE; i++) { printf("%d. ", i); scanf("%d", &input); wasntFound = 1; //Проверяем, встречалось ли такое число. Если да, //то выставляем флаг и выходим из цикла for (j = 0; j <= counter; j++) { if (input == A[j]) { wasntFound = 0; break; } } //Если флаг был поднят, то заносим число в массив if (wasntFound) { A = input; counter++; } } for (i = 0; i < counter; i++) { printf("%d ", A[i]); } getch(); }

4. Der Benutzer gibt eine Zahl ein – die Anzahl der Messungen (von 2 bis 10). Geben Sie anschließend alle Maße ein. Das Programm zeigt den Durchschnittswert, die Varianz und den Fehler an.

#enthalten #enthalten #enthalten #define SIZE 20u void main() ( //Student-Koeffizienten beginnen in zwei Dimensionen const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; unsigned i; unsigned limit; float tmp; float sum = .0f; float mean; float disp; float absError; float relError; do ( printf("Geben Sie die Anzahl der Messungen ein "); scanf("%u", &limit); if (limit > 1 && limit< 11) { break; } } while(1); for (i = 0; i < limit; i++) { printf("#%d: ", i); scanf("%f", &A[i]); sum += A[i]; } mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) { tmp = A[i] - mean; sum += tmp * tmp; } disp = sum / (float)limit; absError = student * sqrt(sum / (float)(limit - 1)); relError = absError / mean * 100; printf("Mean = %.6f\n", mean); printf("Dispertion = %.6f\n", disp); printf("Abs. Error = %.6f\n", absError); printf("Rel. Error = %.4f%", relError); getch(); }

5. Array-Blasensortierung

#enthalten #enthalten #define SIZE 10 #define false 0 #define true !false void main() ( float a = (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0.0 f); float tmp; unsigned i, j; char flag; //Ein Array ausgeben für (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] >a) ( tmp = a[i]; a[i] = a; a = tmp; flag = true; ) ) ) while(flag == true); //Das sortierte Array ausgeben für (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Mischen Sie das Array. Nutzen wir hierfür den Algorithmus

Was sind Arrays in C?

Wie deklariere ich Arrays in C?

Wie initialisiere ich Arrays in C?

Arrays in C für Dummies.

Arrays in C

Ein Array in C ist eine Sammlung von Elementen desselben Typs, auf die per Index zugegriffen werden kann. Die Elemente von Arrays in C liegen nacheinander im Speicher des Computers.

Ein einfaches Beispiel für das Erstellen und Füllen eines Arrays in C:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); return 0 ; )

Wir bekommen:

Im Beispiel deklarieren wir ein Array mit Elementen vom Typ int:

Hier lautet der Array-Name nArr, die Anzahl der Array-Elemente beträgt drei und der Array-Elementtyp ist int.

Ein Array ist eine Sammlung von Elementen. Auf jedes Element des Arrays kann über seine Nummer verwiesen werden. Die Zahl wird üblicherweise als Index bezeichnet. Die Array-Elemente werden beginnend bei Null nummeriert. Weisen wir dem ersten Element des Arrays einen Wert zu, und das erste Element hat den Index Null:

Weisen wir dem zweiten Element des Arrays einen Wert zu, und das zweite Element hat den Index eins:

Weisen wir dem dritten Element des Arrays einen Wert zu, und das dritte Element hat den Index zwei:

Wenn wir Array-Elemente auf dem Bildschirm anzeigen, erhalten wir deren Werte. So:

printf("nArr\t=\t%d\n", nArr);

Um ein Element eines Arrays abzurufen, müssen Sie den Namen des Arrays und den Index des Elements angeben:

Dies ist das erste Element des Arrays, da das erste Element den Index Null hat.

Weisen wir der Variablen int a den Wert des dritten Elements des Arrays zu:

Der Index des dritten Elements des Arrays ist gleich zwei, da die Indizes von Null an gezählt werden.

Nun die allgemeine Regel für die Deklaration von Arrays in C: Wenn Sie ein Array deklarieren, müssen Sie seinen Namen, den Elementtyp und die Anzahl der Elemente angeben. Die Anzahl der Elemente ist eine natürliche Zahl, d.h. Das Ganze ist positiv. Null kann nicht die Anzahl der Elemente sein. Sie können keine variable Anzahl von Array-Elementen angeben. Hier sind Beispiele für Array-Deklarationen in C:

int nArr; // Ein Array wurde deklariert, um einhundert Ganzzahlen zu enthalten;
float fArr; // Ein Array zum Speichern von 5 Gleitkommazahlen wurde deklariert;
char cArr; // Ein Array wurde zum Speichern von zwei Zeichen deklariert;

Es wäre ein Fehler, ein Array mit einer variablen Anzahl von Elementen zu deklarieren:

Int varElem;
int nArr; // Fehler! Die Anzahl der Elemente kann nicht auf eine Variable festgelegt werden;

Sie können die Anzahl der Elemente jedoch mit einem konstanten Wert festlegen: entweder einer direkten positiven Ganzzahl 1, 2, 3 ... oder einer Konstante:

Const int arrayLength = 3;
int nArr;

Wenn Sie ein Array in C deklarieren, können Sie es sofort initialisieren:

int nMassiv = (1, 2, 3);

Sie können die Anzahl der Array-Elemente in eckigen Klammern weglassen, wenn alle Array-Elemente initialisiert sind:

int nMassiv = (1, 2, 3);

Die Anzahl der Elemente wird in diesem Fall automatisch ermittelt.

Sie können bei der Deklaration nur einen Teil der Elemente eines Arrays definieren:

int nMassiv = (1, 2);

In diesem Beispiel werden die ersten beiden Elemente des Arrays initialisiert, das dritte ist jedoch undefiniert.

Beispiel für ein Zeichenarray:

char cArr = ("S", "B", "P");

Bei der Deklaration eines Arrays können Sie nicht die Anzahl der Elemente einer Variablen angeben. Beim Zugriff auf Array-Elemente können Sie jedoch Variablen verwenden:

Int ind = 0;
char cr = cArr;

Dies wird beim Arbeiten mit Schleifen verwendet. Beispiel:

// @author Subbotin B.P..h> void main(void) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

Im Beispiel füllen wir in der ersten Schleife das Array mit Elementen vom Typ int und in der zweiten Schleife zeigen wir diese Elemente auf dem Bildschirm an.