Manipulieren von Array-Elementen in C

Einführung

In diesem Lab lernen Sie, wie Sie Array-Elemente in der C-Programmierung manipulieren können. Das Lab behandelt die grundlegenden Fähigkeiten zum Deklarieren und Initialisieren von Arrays, Zugreifen auf und Modifizieren von Array-Elementen, Iterieren durch Arrays, Durchführen von Array-Berechnungen und dynamischen Speicherzuweisungen für Arrays. Sie werden verschiedene Techniken zum Arbeiten mit Arrays erkunden, einschließlich des Deklarierens und Initialisierens von Arrays mit bestimmten Werten, des teilweisen Initialisierens von Arrays und des dynamischen Zuweisens von Werten an Array-Elemente. Am Ende des Labs werden Sie ein solides Verständnis davon haben, wie Sie Array-Datenstrukturen in C effektiv verwalten und manipulieren können.

Skills Graph

Deklarieren und Initialisieren eines Arrays

In diesem Schritt lernen Sie, wie Sie Arrays in der C-Programmierung deklarieren und initialisieren können. Arrays sind grundlegende Datenstrukturen, die es Ihnen ermöglichen, mehrere Elemente desselben Typs an einem zusammenhängenden Speicherort zu speichern.

Beginnen wir damit, eine neue C-Datei zu erstellen, um die Deklaration und Initialisierung von Arrays zu untersuchen:

cd ~/project
touch array_basics.c

Nun schreiben wir ein Programm, das verschiedene Methoden zur Deklaration und Initialisierung von Arrays zeigt:

#include <stdio.h>

int main() {
    // Methode 1: Deklarieren und Initialisieren eines Arrays mit bestimmten Werten
    int numbers[5] = {10, 20, 30, 40, 50};

    // Methode 2: Deklarieren eines Arrays und spätere Initialisierung
    int scores[3];
    scores[0] = 85;
    scores[1] = 92;
    scores[2] = 78;

    // Methode 3: Teilweise Initialisierung eines Arrays (die restlichen Elemente werden auf 0 gesetzt)
    int grades[4] = {100, 95};

    // Ausgabe der Arrays, um die Initialisierung zu überprüfen
    printf("Numbers array: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    printf("Scores array: ");
    for (int i = 0; i < 3; i++) {
        printf("%d ", scores[i]);
    }
    printf("\n");

    printf("Grades array: ");
    for (int i = 0; i < 4; i++) {
        printf("%d ", grades[i]);
    }
    printf("\n");

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc array_basics.c -o array_basics
./array_basics

Beispielausgabe:

Numbers array: 10 20 30 40 50
Scores array: 85 92 78
Grades array: 100 95 0 0

Lassen Sie uns die Methoden zur Array-Initialisierung analysieren:

1. int numbers[5] = {10, 20, 30, 40, 50};

   • Deklariert ein Integer-Array mit 5 Elementen
   • Initialisiert alle Elemente mit bestimmten Werten
   • Die Größe wird durch die Anzahl der Elemente in der Initialisierungsliste bestimmt

2. int scores[3]; gefolgt von der Zuweisung einzelner Elemente

   • Deklariert zunächst ein Array
   • Weist später Werte an einzelne Elemente zu
   • Nützlich, wenn Sie Werte dynamisch setzen möchten

3. int grades[4] = {100, 95};

   • Initialisiert ein Array teilweise
   • Nicht angegebene Elemente werden automatisch auf 0 gesetzt
   • Spart Zeit, wenn Sie nur einige Anfangswerte setzen möchten

Wichtige Punkte, die Sie sich merken sollten:

• Array-Indizes beginnen bei 0
• Sie müssen den Typ der Elemente angeben, die das Array speichern soll
• Arrays haben eine feste Größe, sobald sie deklariert sind
• Stellen Sie immer sicher, dass Sie nicht über die deklarierte Größe hinaus auf Array-Elemente zugreifen

Zugriff auf und Modifikation von Array-Elementen

In diesem Schritt lernen Sie, wie Sie in der C-Programmierung auf einzelne Elemente eines Arrays zugreifen und diese modifizieren können. Basierend auf dem vorherigen Schritt werden wir untersuchen, wie man mit Indizierung auf Array-Elemente zugreift und verschiedene Methoden zur Manipulation des Array-Inhalts zeigen.

Erstellen wir eine neue C-Datei, um den Zugriff auf und die Modifikation von Array-Elementen zu üben:

cd ~/project
touch array_access.c

Nun schreiben wir ein Programm, das den Zugriff auf und die Modifikation von Array-Elementen demonstriert:

#include <stdio.h>

int main() {
    // Deklarieren und Initialisieren eines Arrays
    int temperatures[5] = {72, 68, 75, 80, 65};

    // Zugriff auf einzelne Array-Elemente
    printf("First temperature: %d\n", temperatures[0]);
    printf("Third temperature: %d\n", temperatures[2]);

    // Modifikation von Array-Elementen
    temperatures[1] = 70;  // Ändern des zweiten Elements
    temperatures[4] = 73;  // Ändern des letzten Elements

    // Ausgabe des modifizierten Arrays
    printf("Modified temperatures: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", temperatures[i]);
    }
    printf("\n");

    // Demonstration einer Berechnung mit Array-Elementen
    int average = (temperatures[0] + temperatures[1] + temperatures[2] +
                   temperatures[3] + temperatures[4]) / 5;
    printf("Average temperature: %d\n", average);

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc array_access.c -o array_access
./array_access

Beispielausgabe:

First temperature: 72
Third temperature: 75
Modified temperatures: 72 70 75 80 73
Average temperature: 74

Lassen Sie uns die wichtigsten Konzepte analysieren:

1. Array-Indizierung

   • Auf Arrays wird mit nullbasierten Indizes zugegriffen
   • temperatures[0] bezieht sich auf das erste Element
   • temperatures[4] bezieht sich auf das letzte Element in einem Array mit 5 Elementen

2. Modifikation von Array-Elementen

   • Einzelne Elemente können direkt über ihren Index geändert werden
   • temperatures[1] = 70; ersetzt das zweite Element durch 70
   • Sie können Elemente an jedem gültigen Index modifizieren

3. Berechnungen mit Array-Elementen

   • Sie können Berechnungen mit einzelnen Array-Elementen durchführen
   • Im Beispiel haben wir die durchschnittliche Temperatur berechnet
   • Greifen Sie in mathematischen Operationen direkt über ihren Index auf Elemente zu

Häufige Fallstricke, die Sie vermeiden sollten:

• Greifen Sie niemals auf einen Array-Index außerhalb seiner Grenzen zu
• Array-Indizes beginnen bei 0, nicht bei 1
• Achten Sie darauf, die deklarierte Größe des Arrays nicht zu überschreiten

Iterieren durch ein Array

In diesem Schritt lernen Sie verschiedene Methoden kennen, um in der C-Programmierung durch Arrays zu iterieren. Iteration ist von entscheidender Bedeutung für die effiziente Verarbeitung von Array-Elementen und die Durchführung verschiedener Operationen auf dem Array-Inhalt.

Erstellen wir eine neue C-Datei, um Techniken zur Array-Iteration zu untersuchen:

cd ~/project
touch array_iteration.c

Nun schreiben wir ein Programm, das mehrere Methoden zur Iteration durch ein Array zeigt:

#include <stdio.h>

int main() {
    // Deklarieren und Initialisieren eines Arrays mit Schülerleistungen
    int scores[6] = {85, 92, 78, 90, 88, 95};
    int total = 0;

    // Methode 1: Verwendung einer Standard-For-Schleife
    printf("Method 1 - Standard For Loop:\n");
    for (int i = 0; i < 6; i++) {
        printf("Score %d: %d\n", i + 1, scores[i]);
        total += scores[i];
    }

    // Berechnen und Ausgeben des Durchschnitts
    float average = (float)total / 6;
    printf("\nTotal Score: %d\n", total);
    printf("Average Score: %.2f\n", average);

    // Methode 2: Umgekehrte Iteration
    printf("\nMethod 2 - Reverse Iteration:\n");
    printf("Scores in reverse order:\n");
    for (int i = 5; i >= 0; i--) {
        printf("Score %d: %d\n", i + 1, scores[i]);
    }

    // Methode 3: Iteration mit einer While-Schleife
    printf("\nMethod 3 - While Loop Iteration:\n");
    int j = 0;
    while (j < 6) {
        if (scores[j] >= 90) {
            printf("High score detected: %d\n", scores[j]);
        }
        j++;
    }

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc array_iteration.c -o array_iteration
./array_iteration

Beispielausgabe:

Method 1 - Standard For Loop:
Score 1: 85
Score 2: 92
Score 3: 78
Score 4: 90
Score 5: 88
Score 6: 95

Total Score: 528
Average Score: 88.00

Method 2 - Reverse Iteration:
Scores in reverse order:
Score 6: 95
Score 5: 88
Score 4: 90
Score 3: 78
Score 2: 92
Score 1: 85

Method 3 - While Loop Iteration:
High score detected: 92
High score detected: 90
High score detected: 95

Wichtige Iterationstechniken:

1. Standard-For-Schleife

   • Die am häufigsten verwendete Methode zur Array-Iteration
   • Ermöglicht eine präzise Kontrolle über den Index
   • Ideal für die Vorwärtsverarbeitung

2. Umgekehrte Iteration

   • Iteriert vom letzten Element zum ersten
   • Nützlich für spezifische Verarbeitungsanforderungen
   • Verwendet einen absteigenden Schleifenzähler

3. Iteration mit einer While-Schleife

   • Bietet eine flexible Iterationskontrolle
   • Kann bedingte Verarbeitung einschließen
   • Nützlich für komplexe Iterationslogik

Wichtige Iterationsprinzipien:

• Definieren Sie immer klare Schleifengrenzen
• Verwenden Sie die Array-Länge, um Zugriffe außerhalb der Array-Grenzen zu vermeiden
• Wählen Sie die für Ihre spezifische Aufgabe am besten geeignete Iterationsmethode

Durchführen von Array-Berechnungen

In diesem Schritt lernen Sie, wie Sie in der C-Programmierung verschiedene Berechnungen mit Arrays durchführen können. Wir werden Techniken zur Ermittlung von Maximal- und Minimalwerten, zur Berechnung von Summen, Durchschnittswerten und zur Anwendung mathematischer Transformationen auf Array-Elemente untersuchen.

Erstellen wir eine neue C-Datei, um Array-Berechnungen zu üben:

cd ~/project
touch array_calculations.c

Nun schreiben wir ein Programm, das verschiedene Techniken zur Array-Berechnung zeigt:

#include <stdio.h>
#include <limits.h>

int main() {
    // Deklarieren und Initialisieren eines Arrays mit Verkaufsdaten
    int sales[7] = {1200, 1500, 980, 1750, 1100, 1300, 1600};

    // Berechnen des Gesamtumsatzes
    int total_sales = 0;
    for (int i = 0; i < 7; i++) {
        total_sales += sales[i];
    }
    printf("Total Weekly Sales: $%d\n", total_sales);

    // Berechnen des durchschnittlichen Tagesumsatzes
    float average_sales = (float)total_sales / 7;
    printf("Average Daily Sales: $%.2f\n", average_sales);

    // Finden des höchsten Tagesumsatzes
    int max_sales = sales[0];  // Starten mit dem ersten Element
    for (int i = 1; i < 7; i++) {
        if (sales[i] > max_sales) {
            max_sales = sales[i];
        }
    }
    printf("Highest Daily Sales: $%d\n", max_sales);

    // Finden des niedrigsten Tagesumsatzes
    int min_sales = sales[0];  // Starten mit dem ersten Element
    for (int i = 1; i < 7; i++) {
        if (sales[i] < min_sales) {
            min_sales = sales[i];
        }
    }
    printf("Lowest Daily Sales: $%d\n", min_sales);

    // Anwenden einer prozentualen Erhöhung
    float increase_percentage = 1.1;  // 10%ige Erhöhung
    printf("\nSales After 10%% Increase:\n");
    for (int i = 0; i < 7; i++) {
        float increased_sale = sales[i] * increase_percentage;
        printf("Day %d: $%.2f\n", i + 1, increased_sale);
    }

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc array_calculations.c -o array_calculations
./array_calculations

Beispielausgabe:

Total Weekly Sales: $9430
Average Daily Sales: $1347.14
Highest Daily Sales: $1750
Lowest Daily Sales: $980

Sales After 10% Increase:
Day 1: $1320.00
Day 2: $1650.00
Day 3: $1078.00
Day 4: $1925.00
Day 5: $1210.00
Day 6: $1430.00
Day 7: $1760.00

Wichtige Techniken zur Array-Berechnung:

1. Gesamtberechnung

   • Verwenden Sie eine Schleife, um alle Array-Elemente zu summieren
   • Summieren Sie die Werte in einer separaten Variablen
   • Nützlich zur Ermittlung der Gesamtsumme

2. Durchschnittsberechnung

   • Teilen Sie die Gesamtsumme durch die Anzahl der Elemente
   • Verwenden Sie Typumwandlung für Fließkomma-Präzision
   • Liefert den Mittelwert der Array-Elemente

3. Finden von Maximal-/Minimalwerten

   • Initialisieren Sie mit dem ersten Array-Element
   • Vergleichen Sie jedes nachfolgende Element
   • Aktualisieren Sie den Maximal-/Minimalwert, wenn ein neues Extremum gefunden wird

4. Elementweise Transformationen

   • Wenden Sie mathematische Operationen auf jedes Element an
   • Können Array-Werte basierend auf bestimmten Regeln ändern
   • Nützlich zum Skalieren, Anpassen oder Transformieren von Daten

Wichtige Berechnungsprinzipien:

• Berücksichtigen Sie immer die Array-Grenzen
• Verwenden Sie geeignete Datentypen
• Seien Sie vorsichtig bei der Ganzzahldivision
• Initialisieren Sie Akkumulatorvariablen vor den Berechnungen

Dynamische Speicherzuweisung für Arrays

In diesem Schritt lernen Sie, wie Sie in der C-Programmierung dynamisch Speicher für Arrays zuweisen können, indem Sie die Funktionen malloc(), realloc() und free() verwenden. Die dynamische Speicherzuweisung ermöglicht es Ihnen, Arrays mit Größen zu erstellen, die zur Laufzeit bestimmt werden.

Erstellen wir eine neue C-Datei, um die dynamische Speicherzuweisung zu untersuchen:

cd ~/project
touch dynamic_array.c

Nun schreiben wir ein Programm, das die dynamische Speicherzuweisung für Arrays demonstriert:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Dynamische Speicherzuweisung für ein Integer-Array
    int array_size;
    printf("Enter the number of elements: ");
    scanf("%d", &array_size);

    // Dynamisch Speicher zuweisen
    int *dynamic_array = (int *)malloc(array_size * sizeof(int));

    // Prüfen, ob die Speicherzuweisung erfolgreich war
    if (dynamic_array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // Eingabe der Array-Elemente
    printf("Enter %d integers:\n", array_size);
    for (int i = 0; i < array_size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &dynamic_array[i]);
    }

    // Ausgabe der Array-Elemente
    printf("\nArray elements:\n");
    for (int i = 0; i < array_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // Dynamisch die Größe des Arrays ändern
    int new_size;
    printf("\nEnter new array size: ");
    scanf("%d", &new_size);

    // Speicher neu zuweisen
    int *resized_array = (int *)realloc(dynamic_array, new_size * sizeof(int));

    // Prüfen, ob die Neuzuweisung erfolgreich war
    if (resized_array == NULL) {
        printf("Memory reallocation failed!\n");
        free(dynamic_array);
        return 1;
    }

    dynamic_array = resized_array;

    // Wenn die neue Größe größer ist, neue Elemente initialisieren
    if (new_size > array_size) {
        for (int i = array_size; i < new_size; i++) {
            dynamic_array[i] = 0;
        }
    }

    // Ausgabe des neu dimensionierten Arrays
    printf("Resized array:\n");
    for (int i = 0; i < new_size; i++) {
        printf("%d ", dynamic_array[i]);
    }
    printf("\n");

    // Dynamisch zugewiesenen Speicher freigeben
    free(dynamic_array);

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc dynamic_array.c -o dynamic_array
./dynamic_array

Beispielinteraktion:

Enter the number of elements: 3
Enter 3 integers:
Element 1: 10
Element 2: 20
Element 3: 30

Array elements:
10 20 30

Enter new array size: 5
Resized array:
10 20 30 0 0

Wichtige Konzepte der dynamischen Speicherzuweisung:

1. malloc()-Funktion

   • Weist den angeforderten Speicher zu und gibt einen Zeiger zurück
   • Syntax: pointer = (type *)malloc(size * sizeof(type))
   • Prüfen Sie immer auf NULL, um eine erfolgreiche Zuweisung sicherzustellen

2. realloc()-Funktion

   • Ändert die Größe eines zuvor zugewiesenen Speicherblocks
   • Kann die Arraygröße erhöhen oder verringern
   • Bewahrt die vorhandenen Daten beim Vergrößern auf

3. free()-Funktion

   • Gibt dynamisch zugewiesenen Speicher frei
   • Verhindert Speicherlecks
   • Muss für jede malloc()/realloc()-Zuweisung aufgerufen werden

Wichtige Prinzipien der Speicherzuweisung:

• Prüfen Sie immer, ob die Zuweisung erfolgreich war
• Geben Sie dynamisch zugewiesenen Speicher frei, wenn er nicht mehr benötigt wird
• Seien Sie vorsichtig, wenn Sie die Größe von Arrays ändern
• Behandeln Sie potenzielle Zuweisungsfehler gracefully

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in der C-Programmierung Arrays deklarieren und initialisieren, auf Array-Elemente zugreifen und diese modifizieren, durch Arrays iterieren, Array-Berechnungen durchführen und dynamisch Speicher für Arrays zuweisen können. Sie haben verschiedene Methoden zur Deklaration und Initialisierung von Arrays untersucht, darunter das direkte Angeben von Werten, die spätere Zuweisung von Werten und die partielle Initialisierung von Arrays. Sie haben auch gelernt, wie Sie den Inhalt von Arrays ausgeben, um ihre Initialisierung zu überprüfen. Diese grundlegenden Array-Operationen sind für die Arbeit mit Datenstrukturen in C unerlässlich und bilden die Bausteine für komplexere Array-Manipulationen.