Array in C

Einführung

In einfachen Worten, an Array ist eine Gruppe von Variablen or den lineare Sammlung ähnlicher Elemente.

Mit „ähnlichen Elementen“ meinen wir, dass alle Daten von der gleicher Datentyp Dies kann entweder int, char, float, double usw. sein. Wenn wir sagen, dass einige Daten in einem Array vom Typ 'float' und der Rest vom Typ 'char' sind, ist dies nicht gültig.

Beispiel intx [5];

Das obige Beispiel deklariert ein Array vom Typ 'int', das eine Sammlung von 5 Elementen ist.

Array in C

Warum Array in C?

Das Array ist eine Methode, die unsere komplexen Probleme einfacher machen kann. Angenommen, ein Schüler muss die Noten von 10 Fächern speichern und seinen Gesamtprozentsatz berechnen. Es ist also nicht unmöglich, für jedes Fach 10 verschiedene Variablen zu deklarieren, aber eine größere Aufgabe, und was ist, wenn die Anzahl der Fächer auf 50 oder noch mehr steigt. Hier ist das Array eine Lösung für solche Probleme.

Deklaration eines Arrays in C

Syntax:

Datentyp Array_Name [Array_Größe];

Beispiel: intn[10];

In der obigen Deklaration wird ein Array vom Typ 'int' deklariert.

n[ ] wird verwendet, um ein Array 'n' zu bezeichnen, was bedeutet, dass 'n' ein Array ist.

Ein Array kann auf viele Arten deklariert werden, aber es gibt einige Arten, die nicht gültig genug sind, um ein Array zu deklarieren. Einige der gültigen und ungültigen Erklärungen sind unten aufgeführt.

intn[10]; ein Array vom Typ 'int' wird deklariert von Größe 10 dh 'n' Array ist eine Sammlung von 10 Elementen vom Typ 'int'.

 

int n[ ]; ist ein ungültig Deklaration, da die Größe des Arrays nicht angegeben ist. Es ist wichtig, ein Array mit seiner Größe zu deklarieren, da der Compiler Platz im Speicher für das Array zuweisen muss, was nicht möglich ist, wenn die Klammern '[ ]' leer sind. Die 'int n[10]'-Anweisung ist ausreichend, da der Compiler jetzt die Größe des Arrays mit Hilfe der Anzahl der Elemente, die er speichern kann, erkennt und dann Platz für 10 Elemente im Speicher zuweist.

 

int n[ ] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; ist ein gültig Erklärung. Die Deklaration wird durchgeführt und dem Array werden gleichzeitig Werte zugewiesen und das Array ist initialisiert sowie. Wir können also die Array-Größe überspringen, da der Compiler die Größe aus den zugewiesenen Werten erfährt, dh {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}.

 

int n[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; ist auch eine gültig Initialisierung.

 

int n[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; is kein gültiges Initialisierung, da die Elemente im Array größer als die eingegebene Größe sind und dies zu einem Fehler führt.

12345678910

 

 

Für die restlichen Elemente im Array ist kein Platz mehr.

 

int n[10] = {1, 2, 3, 4, 5, 6, 7} ; ist ein gültig Initialisierung. In solchen Fällen, wenn die Elemente im Array kleiner als ihre Größe sind, werden die restlichen Blöcke mit 0 gefüllt.

1234567000

 

Wenn bei der Deklaration keine Initialisierung erfolgt, gibt es in allen Blöcken Müllwerte, dh 0.

Deklaration eines Arrays in C

Index eines Arrays in C

Jedes Element in einem Array hat seinen eigenen Indexwert.

int x[5] = {10, 20, 30, 40, 50};

verschiedenste Komponenten1020304050
Index01234

          

Oben ist das Array 'x' mit seinen Elementen und den Indexwerten dargestellt. 0,1,2,3,4 sind die 'Indizes'.

Ein Indexwert des ersten Elements ist immer 0 oder

Der Index eines Arrays beginnt mit 0.

Mit Hilfe dieser Indizes können wir zufällig auf jedes Element des Arrays zugreifen.

Syntax: Array_Name [ Index]

Das oben geschriebene Array 'x' hat 5 Elemente. Wir können also auf diese Elemente zugreifen als:

x[0] gibt den Wert des ersten Elements zurück, also 10.

Ebenso
x[1] ist 20
x[2] ist 30
x[3] ist 40
x[4] ist 50

Index eines Arrays in C

Außerdem sind x[0], x[1] dieselben wie die Variablen, die wir bisher verwendet haben. Wir können diesen Variablen auch Werte zuweisen wie x[1]=89; wie bei anderen Variablen (x=5;, y=10; usw.)

Zuweisen von Werten zu Array in C

Der oben diskutierte Begriff „Initialisierung“ wird mit diesem Thema deutlich.

Werte können einem Array auf unterschiedliche Weise zugewiesen werden. Die erste Möglichkeit besteht darin, die Werte den Elementen des Arrays während der Deklaration zuzuweisen.

int n[ ] = {1, 2, 3, 4, 5} ; indem wir dies schreiben, deklarieren und weisen wir dem Array gleichzeitig Werte zu. Damit haben wir ein Array initialisiert.

Die zweite Möglichkeit besteht darin, zuerst das Array zu deklarieren und dann die Werte separat zuzuweisen.

intn[3]; Diese Anweisung deklariert ein Array, aber die Werte sind noch nicht zugewiesen. 'int n[3]' reserviert Platz von 3 ganzen Zahlen im Speicher, aber solange keine Werte zugewiesen werden, bleiben diese Plätze leer. Um es zu initialisieren, müssen wir jedem der Elemente des Array-ähnlichen,

n[0]=2;

n[1]=9;

n[2]=6;

Dies ist dasselbe, wie wir Variablen deklarieren und ihnen dann Werte zuweisen.

intx, y;

x = 89;

y = 10;

Kurz gesagt, die beiden Methoden zum Zuweisen von Werten zu einem Array sind:

Methode:1 Deklaration und Zuweisung erfolgen gleichzeitig.

int n[ ]= {1,2,3,4,5};

Methode:2 Deklarieren Sie zunächst das Array mit seiner Größe. Weisen Sie die Werte später den Elementen des Arrays zu.

int n[ 3];

n[0]=5;

n[1]=8;

n[2]=4;

 

Das Array kann einen beliebigen Datentyp haben, int, char, float usw. Siehe die Beispiele für Arrays mit unterschiedlichen Datentypen.

float f[ ]={1.1, 2.2, 3.3};

char c[ ]={'a', 'b', 'c'};

 

Lassen Sie uns ein Programm erstellen, um die Durchschnittsnoten und den Gesamtprozentsatz eines Schülers in seinen 5 Fächern zu berechnen. Jedes Fach hat 100 Punkte und die Fächer sind Physik, Chemie, Mathematik, Englisch und Computer.

PROGRAMM

#enthalten int main () { int M [5]; Schwimmer A; printf("Geben Sie Noten in Physik ein:"); scanf("%d",&M[0]); printf("Noten in Chemie eingeben:"); scanf("%d",&M[1]); printf("Noten in Mathematik eingeben:"); scanf("%d",&M[2]); printf("Markierungen auf Englisch eingeben:"); scanf("%d",&M[3]); printf("Markierungen in Computer eingeben:"); scanf("%d",&M[4]); int summe=(M[0]+M[1]+M[2]+M[3]+M[4]); A=Summe/5.0; printf("Durchschnittsnoten:%.2f",A); Float-Prozentsatz = (Summe / 500.0) * 100; printf("\nProzent=%.2f",Prozent); 0 zurückgeben; }

 

AUSGABE:

Zuweisen von Werten zu Array in C

Ein Beispiel aus unserer Praxis macht das Konzept noch klarer und verständlicher.

int M[5]; hier deklarieren wir einfach ein Array der Größe 5, ohne es zu initialisieren, da wir möchten, dass der Benutzer seine eigenen Daten eingibt.

Danach behandelten wir, während wir Eingaben vom Benutzer nahmen, Elemente eines Arrays genauso wie wir normale Variablen behandelt hatten. &marks[0], &marks[1] repräsentieren die Adressen von marks[0] bzw. marks[1].

Der Rest des Codes enthält die Operation, die zum Berechnen der durchschnittlichen Markierungen und des Prozentsatzes erforderlich ist.

A = Summe/5.0; 'A' wird als Float-Variable deklariert, da der Durchschnitt von Integer-Werten auch float sein kann. Deshalb wird die Division von 'Summe' mit 5.0 vorgenommen, so dass ein Float-Wert zurückgegeben wird, der dann 'A' zugewiesen wird. Aber wenn die 'Summe' durch 5 geteilt wird, wird als Ergebnis ein ganzzahliger Wert zurückgegeben.

Verwendung der for-Schleife in Arrays in C

Schleifen mit Arrays sind der einfachste Weg, um schwierige Probleme zu lösen.

PROGRAMM

#enthalten int main( ) { int i,j; int A[5]; for(i=0; i<5;i++) { printf("Geben Sie den Wert von n[%d] ein",i); scanf("%d",&A[i]); } for(j=0;j<5;j++) { printf("A[%d]=%d\n",j,A[j]); } Rückgabe 0; }

 

AUSGABE:

Verwendung der for-Schleife in Arrays in C

Der obige Code ist der einfachste Ansatz, um Sie mit Schleifen und Arrays vertraut zu machen. Wir haben zwei Variablen deklariert 'i','j' wie Iteratoren und ein Array 'A' der Größe 5. Der Code ist einfach, zuerst müssen wir unsere Daten eingeben und dann werden die eingegebenen Daten als Ausgabe angezeigt.

Die erste 'for'-Schleife mit 'i'-Iterator dient dazu, Eingaben vom Benutzer aufzunehmen.

für(i=0; i<5;i++) 'i' wird mit 0 initialisiert, da der Startindex des Arrays 0 ist und bis 4 geht.

Das gleiche ist mit für(j=0;j<5;j++) Die Anweisung 'j' beginnt bei 0 und endet bei 4. Diese 'for'-Schleife zeigt die vom Benutzer eingegebenen Daten in einer Reihenfolge an.

Nichts ist komplex, wie wir im Ausgabeabschnitt beobachten können. Wie bereits gesagt, behandeln Sie Elemente des Arrays als normale Variablen und die Dinge werden entsprechend ablaufen.

Hinweis: Die Speicherzuweisung in einem Array erfolgt kontinuierlich. Wenn zum Beispiel die Adresse des ersten Elements eines Arrays mit Index 0 22334456 ist, dann ist der Adresswert des zweiten Elements mit Index 1 22334460 (22334456+4; da 4 die Größe einer ganzen Zahl ist) und der dritte ist 22334464 und so weiter. Es ist wichtig zu beachten, dass alle Elemente eines Arrays zusammen in einer seriellen Reihenfolge gespeichert werden.

Zeiger eines Arrays in C

Jedes Konzept in einer Programmiersprache wird entwickelt, um die anderen Tools zu vereinfachen. Die Verwendung des Arrays in den Zeigern ist ein sehr wichtiges Thema. Wir sind also alle mit der Deklaration und Initialisierung eines Arrays fertig. Jetzt werden wir sehen, wie wir Arrays in Zeigern verwenden können. Aber bevor wir fortfahren, hoffen wir, dass Sie die Themenhinweise durchgegangen sind und genügend Probleme damit üben. Wenn nicht, klären Sie zunächst die Grundlagen der Zeiger, um dieses interessante Konzept besser zu verstehen.

Da wir alle wissen, ist Pointer eine Variable, die auf eine andere Variable zeigt. Es speichert die Adresse des Wertes der Variablen, auf die es zeigt. Sagen wir 'A' zeigt auf 'B' bedeutet, dass sowohl 'A' als auch 'B' Variablen sind, aber 'A' ist ein Zeiger. Der Wert von 'A' ist der Adresswert von 'B'.

Angenommen, wir haben ein Array namens 'n'. 'p' ist eine Variable, die auf 'n' zeigt, was bedeutet, dass 'p' ein Zeiger auf 'n' ist. Da das Array nun aus mehreren Elementen besteht, stellt sich die Frage, auf welches Element des Arrays der Zeiger 'p' zeigt.

Pointer 'p' enthält den Adresswert des ersten Elements, dh n[0] des Arrays.

Der Zeiger eines Arrays ist der Zeiger auf sein erstes Element oder der Name des Arrays ist der Zeiger auf das erste Element des Arrays.

int. Student [5]; int *p; p=&Schüler[0];

 

Lassen Sie uns nun den oben geschriebenen Code verstehen.

'student' ist ein Array und 'p' ist ein Zeiger auf das 'student'-Array 'p' zeigt auf student[0]. Deshalb die Aussage p=&student[0]; weist 'p' den Adresswert des ersten Elements des Arrays zu.

int-Student [5];

int * p;

p = Schüler;

Der oben geschriebene Code ist ebenfalls gültig. Die Aussage p = Schüler; funktioniert genauso wie der vorherige. Der Name des Arrays selbst ist der Zeiger auf das erste Element des Arrays.

p = Schüler; diese Anweisung weist 'p' auch die Adresse des ersten Elements des Arrays 'student' zu.

Da 'p' auf das erste Element des Arrays zeigt, ist der Wert von '*p' ist gleich dem ersten Element des Arrays, dh *p= schüler[0]

Was ist dann mit den restlichen Elementen des Arrays?

Wenn sich '*p' auf das erste Element des Arrays bezieht, dann * (p + 1) bezieht sich auf das zweite Element des Arrays, * (p + 2) verweist auf das dritte Element des Arrays und so weiter.

Damit sind wir mit dem theoretischen Teil der Zeiger im Zusammenhang mit dem Array fertig. Sehen Sie sich nun die Programme an, die Ihnen ein besseres Verständnis vermitteln.

PROGRAMM

#enthalten int main() {int A[5]={12,24,36,48,60}; int *p; int ich; p=A; printf("Adresswert von A[0]: %d\n",p); for(i=0;i<5;i++) { printf("Adresse von A[%d]: %d\n",i,&A[i]); } Rückgabe 0; }

 

AUSGABE:

Zeiger eines Arrays in C

Wir haben also zunächst bewiesen, dass der Name des Arrays der Zeiger auf das erste Element des Arrays ist. Als Aussage p = A; liefert die Ausgabe, die gleich dem Adresswert des ersten Elements ist.

Nach der Verwendung der 'for'-Schleife geben wir den Adresswert jedes Elements aus, der deutlich zeigt, dass alle Werte mit einer Differenz 4 in aufsteigender Reihenfolge sind.

PROGRAMM

#enthalten int main() {int A[5]={12,24,36,48,60}; int *p; int ich; p=A; for(i=0;i<5;i++) { printf("Wert von *(p+%d)=%d\n",i,*(p+i)); } Rückgabe 0; }

 

AUSGABE:

Array in C Beispiel

Da 'p' auf das erste Element des Arrays zeigt, enthält *p oder *(p+0) den Wert von A[0]. Ebenso ist *(p+1) gleich A[1] und so weiter, wie im Ausgabefenster gezeigt.

Hinterlassen Sie eine Nachricht

Diese Seite verwendet Akismet, um Spam zu reduzieren. Erfahren Sie, wie Ihre Kommentardaten verarbeitet werden.