C/C++ Schritt-für-Schritt - Seite 7

07. Schritt-für-Schritt C/C++ — C Programmierung - Arrays

| | 5. Arten von Arrays | | - Eindimensionale Arrays 1. Element anhängen

2. Element einfügen
3. Element löschen
4. Element ersetzen
5. Element suchen
6. Löschen des Arrays
7. Sortierung eines Arrays - Mehrdimensionale Arrays
   Matrixoperationen mit mehrdimensionalen Arrays | |

1. Einführung in Arrays

Eine Variable kann einen konstanten Wert halten. Nur einen einzigen konstanten Wert und es ist nicht möglich, mehr als einen Wert in einer Variablen zu halten.

Das folgende Beispiel zeigt den Geltungsbereich einer Variablen.

| | int main()
{
int sno;
sno = 1001;
sno = 1008;
sno = 1005;
printf(“%d”, sno);
return 0;
} | | | Ausgabe:
1005 |

Das obige Programm kann nur 1005 anzeigen, aber nicht alle Werte (d.h. 1001, 1008, 1005 ).

Können wir das folgende Programm anstelle des obigen Programms verwenden.

| | int main()
{
int sno;
sno 0 = 1001;
sno 1 = 1008;
sno 2 = 1005;
printf(“%d”, sno);
return 0;
} | | | Ausgabe:
Nichts,
Das obige Programm zeigt eine Liste von Fehlern an, weil der Ansatz falsch ist. |

Lassen Sie uns mit dem folgenden Programm fortfahren, um ein Programm mit 0 Fehlern zu erhalten.

| | int main()
{
int sno[3];
sno[0] = 1001;
sno[1] = 1008;
sno[2] = 1005;
printf(“%d”, sno[2] );
return 0;
} | / 3 Werte zum Einfügen /
/ Erste Position zum Einfügen von 1001 /
/ Nächste Position zum Einfügen von 1008 /
/ und Nächste Position zum Einfügen von 1005 /
/ Gibt den Wert der 2. Position aus / | | | | | Ausgabe:
Nichts | |

Das obige Programm zeigt eine Liste von Fehlern an, weil der Ansatz falsch ist.

Je nach dem obigen Programm kann die Variable sno mehr als eine Studentennummer halten. Es ist einfach, indem man die Mehrfachstandortechnik verwendet, die auch als Arrays bekannt ist.

2. Über Arrays

Arrays enthalten eine Anzahl von Datenelementen desselben Typs. Dieser Typ kann ein einfacher Datentyp, eine Struktur oder eine Klasse sein. Die Elemente in einem Array werden als Elemente bezeichnet. Die Nummer greift auf Elemente zu; diese Nummer wird als Index bezeichnet. Elemente können beim Definieren des Arrays auf bestimmte Werte initialisiert werden.

Arrays können mehrere Dimensionen haben.

Ein zweidimensionales Array ist ein Array von Arrays. Die Adresse eines Arrays kann als Argument an eine Funktion übergeben werden; das Array selbst wird nicht kopiert. Arrays können als Mitgliedsdaten in Klassen verwendet werden. Es muss darauf geachtet werden, dass keine Daten außerhalb eines Arrays im Speicher platziert werden.

/ Das folgende Programm liest das Alter von 4 Personen und zeigt es an /

| | / 47_arrays.c /
#include
int main()
{
int age[4], i;
for( i=0; i<4; i++)
{
printf(“Geben Sie ein Alter ein “); scanf(“%d”, &age[i]);
}

for(i=0; i<4; i++)
printf(“\nSie haben %d eingegeben”, age[i]);

return 0;
} |

| | |

Wie andere Variablen in C muss ein Array definiert werden, bevor es verwendet werden kann, um Informationen zu speichern. Und wie andere Definitionen gibt eine Array-Definition einen Variablentyp und einen Namen an.

Aber es enthält ein weiteres Merkmal: eine Größe. Die Größe gibt an, wie viele Datenelemente das Array enthalten wird. Sie folgt unmittelbar dem Namen und ist von eckigen Klammern umgeben.

3. Array-Elemente

Die Elemente in einem Array werden als Elemente bezeichnet. Eindimensionale Arrays akzeptieren Werte entweder zeilenweise oder spaltenweise. Es kann nur einen Satz von Werten speichern.
Das erste Array-Element ist 0, das zweite ist 1 und so weiter.

| | |

Ein Array-Wert kann direkt zur Entwurfszeit initialisiert werden.
Die Initialisierung von Arrays erfolgt wie folgt..

| | |

4. Arrays an Funktionen übergeben

Arrays können als Argumente an Funktionen verwendet werden.

In einer Funktionsdeklaration stellen der Datentyp und die Größen des Arrays die Array-Argumente dar.

void display(float [DISPLAY][MONTHS]);

Wenn die Funktion aufgerufen wird, wird nur der Name des Arrays als Argument verwendet.

 display(sales); 

Programm zur Annahme und Ausgabe eines Arrays von 10 Elementen

| | / 48_ ele10.c /
#define MAX 10
display(int a[MAX])
{
int i;
for(i = 0;iprintf(“\n%d”,,a[i]);
}

int main()
{
int x[MAX], i;
for(i=0;iscanf(“%d”,&x[i]);

display(x);

return 0;
} |

Das Zurückgeben von Array-Werten aus Funktionen ist ebenfalls möglich, aber wir müssen das Konzept der Zeiger klar verstehen. Bitte schauen Sie sich die Themen zu Zeigern für weitere Informationen an.

5. Klassifizierung von Arrays

Arrays sind von zwei Typen.

| | 1. Eindimensionale Arrays

2. Mehrdimensionale Arrays |

1. Eindimensionale Arrays

Ein eindimensionales Array ist eine Sammlung von Elementen in einer Zeilen- oder Spaltenanordnung.
Ein eindimensionales Array kann die folgenden Operationen akzeptieren.

| | 1. Element anhängen

2. Element einfügen
3. Element löschen
4. Element ersetzen
5. Element suchen
6. Löschen des Arrays
7. Sortierung eines Arrays |

Das folgende Programm kann alle oben beschriebenen Aufgaben ausführen.

| | / ARRAY FUNCTIONS /
/ 49_sarray.c /
#define N 100
#define M 10
int i,j,r,c,r1,r2,c1,c2; / Array-Elemente lesen /
int accept_values(int a[N])
{
int n;
printf(“\nWie viele Werte möchten Sie eingeben..? “);
scanf(“%d”,&n);
printf(“\nGeben Sie die Datenelemente ein..\n”);
for(i=0;iscanf(“%d”,&a[i]);
return n;
} / Array-Elemente anzeigen /
void display(int a[N],int n)
{
printf(“\n Array-Elemente sind…”);
for(i=0;iprintf(“\n%d”,a[i]);
} / Array-Element löschen /
int delete_cell(int a[N],int n)
{
int pos;
char ch;
printf(“\nGeben Sie die Position des zu löschenden Elements ein: “);
scanf(“%d”,&pos);
for(i=pos-1;ia[i] = a[i+1];
n–;
printf(“\n Möchten Sie fortfahren..(y/n)?”);
ch = getche();
if(ch == ‘y’) delete_cell(a,n);
return n;
} / Array-Element einfügen /
int insert_cell(int a[N],int n)
{
int pos, new;
char ch;
printf(“\nGeben Sie das einzufügende Element ein: “); scanf(“%d”,&new);
printf(“\nGeben Sie die Einfügeposition ein: “); scanf(“%d”,&pos);
for(i=n;i>=pos;i–)
a[i] = a[i-1];
a[pos-1] = new;
n++;

printf(“\n Möchten Sie fortfahren..(y/n)?”);
ch = getche();
if(ch==’y’) insert_cell(a,n);
return n;
} / Element zu einem bestehenden Array anhängen /
int append_cell(int a[N],int n)
{
int pos, new;
char ch;
printf(“\nGeben Sie das anzuhängende Element ein: “);
scanf(“%d”,&new);
a[n] = new;
n++;
printf(“\n Möchten Sie fortfahren..(y/n)?”);
ch = getche();
if(ch==’y’)append_cell(a,n);
return n;
} / Eine Liste von Elementen eines Arrays in absteigender Reihenfolge sortieren /
void sort_list_descend(int a[N],int n)
{
int temp;
for(i=0;ifor(j=i;jif(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf(“\nDie sortierten Elemente in absteigender Reihenfolge sind…”);
} / Eine Liste von Elementen eines Arrays in aufsteigender Reihenfolge sortieren /
void sort_list_ascend(int a[N],int n)
{
int temp;
for(i=0;ifor(j=i;jif(a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf(“\nDie sortierten Elemente in aufsteigender Reihenfolge sind…”);
} / Um das kleinste und größte Element eines bestehenden Arrays zu finden /
void small_big(int a[N],int n)
{
int temp;
for(i=0;ifor(j=i;jif(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf(“\nDas kleinste Element ist : %d”,a[n-1]);
printf(“\nDas größte Element ist : %d”,a[0]);
} / Suche nach einem Element in einem Array /
void search(int a[N],int n)
{
int target, temp=0;
printf(“\nGeben Sie das zu suchende Element ein: “);
scanf(“%d”,&target);
for(i=0;iif(a[i] == target)
{
printf(“\nGefunden an Position Nr. %d”,i+1);
temp = 1;
}
if(temp == 0)
printf(“\nNicht gefunden”);
} / Hauptprogramm / / Um einfache Array-Operationen zu demonstrieren /
#include
#include #define m 100
int main()
{
int a[m],n; char ch;
clrscr();
n = accept_values(a);
do
{
printf(“\n 1 - Append_cell”);
printf(“\n 2 - Delete_cell”);
printf(“\n 3 - Insert_cell”);
printf(“\n 4 - Sort_list_descend”);
printf(“\n 5 - Sort_list_ascend”);
printf(“\n 6 - Small_big”);
printf(“\n 7 - Search”);
printf(“\n 8 - Remove_list”);
printf(“\n 9 - Exit”);
printf(“\nGeben Sie Ihre Wahl ein: “); ch = getche();
printf(“\n”);
switch(ch)
{
case ‘1’: n = append_cell(a,n); break;
case ‘2’: n = delete_cell(a,n); break;
case ‘3’: n = insert_cell(a,n); break;
case ‘4’: sort_list_descend(a,n); break;
case ‘5’: sort_list_ascend(a,n); break;
case ‘6’: small_big(a,n); break;
case ‘7’: search(a,n); break;
case ‘8’: n = 0; break;
case ‘9’: printf(“\nDies wird Ihr Programm beenden.”); break;
}
display(a,n);
printf(“\nMöchten Sie erneut ausführen..(y/n)?”);
ch = getche();
}
while(ch!=’9’);
return 0;
} |

2. Mehrdimensionale Arrays

Ein mehrdimensionales Array ist eine Sammlung von Elementen in Zeilen- und Spaltenanordnung.
Ein mehrdimensionales Array kann die folgenden Operationen akzeptieren.

Ein mehrdimensionales Array wird häufig in den Bereichen Matrizen verwendet, um ganze Aufgaben auf die einfachste Weise zu verstehen.

MATRIXFUNKTIONEN

| | / 50_menumat.c /
#define N 100
#define M 10
int i, j, r, c, r1, r2, c1, c2; / Werte für eine MATRIX lesen /
void read_matrix(int A[M][M])
{
printf(“\nWie viele Zeilen? “);
scanf(“%d”,&r);
printf(“\nWie viele Spalten? “);
scanf(“%d”,&c);
for(i=0;ifor(j=0;jscanf(“%d”,&A[i][j]);
} / Werte einer MATRIX schreiben /
void disp_matrix(int A[M][M])
{
for(i=0;i{
for(j=0;jprintf(“%5d”,A[i][j]);
printf(“\n”);
}
} / Um die TRANSPOSE für eine MATRIX JEDER ORDNUNG zu finden /
void tra_matrix_1(int T[M][M],int A[M][M])
{
printf(“\nDie Transponierte von A ist\n”);
for(i=0;i{
for(j=0;j{
T[i][j] = A[j][i];
printf(“%5d”,T[i][j]);
}
printf(“\n”);
}
} / Um zwei MATRIZEN zu ADDIEREN
( möglich, nur wenn sie von GLEICHER ORDNUNG sind ) /
void add_matrix(int C[M][M],int A[M][M],int B[M][M])
{
for(i=0;ifor(j=0;jC[i][j] = A[i][j] + B[i][j];
printf(“\nDie Summe von A und B ist”);
} / Um MATRIZEN JEDER ORDNUNG zu MULTIPLIZIEREN
( vorausgesetzt, sie folgen der MATRIXMULTIPLIKATIONSREGEL ) /
void mul_matrix_1(int C[M][M],int A[M][M],int B[M][M])
{
int k;
printf(“\nDas Produkt von A und B ist.. “);
printf(“\nMatrix C\n”);
for(i=0;i{
for(j=0;j{
C[i][j]=0;
for(k=0;kC[i][j] = C[i][j]+(A[i][k]B[k][j]);
printf(“%5d”,C[i][j]);
}
printf(“\n”);
}
} / Um zwei MATRIZEN zu SUBTRAHIEREN
( möglich, nur wenn sie von GLEICHER ORDNUNG sind ) /
void sub_matrix(int C[M][M],int A[M][M],int B[M][M])
{
for(i=0;ifor(j=0;jC[i][j] = A[i][j] - B[i][j];
printf(“\nDie Differenz von A und B ist”);
} / Ein MENÜ-gesteuertes Programm zur Durchführung von MATRIX-Operationen */
#include
#include
int main()
{
int A[M][M],B[M][M],C[M][M],T[M][M]; char ch;
clrscr( );
printf(“\nGeben Sie die Elemente der Matrix A ein.. “); read_matrix(A); r1=r; c1=c;
printf(“\n Matrix A\n”); disp_matrix(A);
printf(“\nGeben Sie die Elemente der Matrix B ein.. “); read_matrix(B); r2=r; c2=c;
printf(“\n Matrix B\n”);disp_matrix(B);
do {
printf(“\n1:Addition”);
printf(“\n2:Subtraktion”);
printf(“\n3:Multiplikation”);
printf(“\n4:Transponieren”);
printf(“\n5:Beenden”);
printf(“\nGeben Sie Ihre Wahl ein..”); ch = getche();
switch(ch)
{
case ‘1’:
if(r1==r2 && c1==c2)
{
add_matrix(C,A,B);printf(“\nMatrix C\n”);
disp_matrix(C);
}
else
{
printf(“\nIhre eingegebenen Werte von r1,r2 && c1,c2 sind nicht gleich,”);
printf(“\nhiermit kann ich diese Matrixaddition nicht durchführen.”);
printf(“\nBitte geben Sie die richtigen Matrizen ein.”);
} break;

case ‘2’:
if(r1==r2 && c1==c2)
{
sub_matrix(C,A,B);printf(“\nMatrix C\n”);
disp_matrix(C);
}
else
{
printf(“\nIhre eingegebenen Werte von r1,r2 && c1,c2 sind nicht gleich,”);
printf(“\nhiermit kann ich diese Matrixsubtraktion nicht durchführen.”);
printf(“\nBitte geben Sie die richtigen Matrizen ein.”);
} break;

case ‘3’:
if(c1==r2)
mul_matrix_1(C,A,B);
else
{
printf(“\nDie Spalten(c1) der Matrix A sind NICHT GLEICHEN”);
printf(“Zeilen(r2) der Matrix B.”);
printf(“\nDaher kann ich diese Matrixmultiplikation nicht durchführen.”);
printf(“\nBitte geben Sie Matrizen ein, sodass c1 == r2.”);
} break;

case ‘4’:
printf(“\nDie Ordnung der Matrix A ist %d x %d”,r1,c1);
tra_matrix_1(T,A);
printf(“\nDie Ordnung der Transponierten von A ist %d x %d”,c1,r1); break;

case ‘5’: printf(“\nDies wird Ihr Programm beenden.”); break;
}
printf(“\nMöchten Sie erneut ausführen…[y/n]? “); ch=getche();
}while(ch!=’5’);
return 0;
}