Zweidimensionale Arrays in C erstellen

Einführung

In diesem Lab werden Sie lernen, wie Sie zweidimensionale Arrays in C erstellen und manipulieren. Sie beginnen damit, zweidimensionale Arrays zu deklarieren und erkunden dann verschiedene Methoden, um sie zu initialisieren. Als Nächstes lernen Sie, wie Sie auf die Elemente der Arrays zugreifen und sie manipulieren können. Schließlich wenden Sie Ihr Wissen an, um die Durchschnittsnoten für zwei Fächer zu berechnen und die Funktionalität der zweidimensionalen Arrays zu erweitern. Dieses Lab vermittelt ein umfassendes Verständnis der Arbeit mit zweidimensionalen Arrays in der Programmiersprache C.

Deklarieren von zweidimensionalen Arrays

In diesem Schritt lernen Sie, wie Sie zweidimensionale Arrays in C deklarieren. Zweidimensionale Arrays sind im Wesentlichen Arrays von Arrays, die es Ihnen ermöglichen, Daten in einer gitterartigen Struktur mit Zeilen und Spalten zu speichern.

Beginnen wir damit, eine neue C-Datei zu erstellen, um die Deklaration von zweidimensionalen Arrays zu demonstrieren:

touch ~/project/two_dimensional_arrays.c

Nun schreiben wir unsere erste Deklaration eines zweidimensionalen Arrays:

#include <stdio.h>

int main() {
    // Declare a 3x4 integer two-dimensional array
    int grades[3][4];

    return 0;
}

In diesem Beispiel ist grades ein zweidimensionales Array mit 3 Zeilen und 4 Spalten. Das bedeutet, dass es insgesamt 12 Ganzzahlwerte speichern kann (3 × 4 = 12).

Lassen Sie uns verschiedene Möglichkeiten zur Deklaration von zweidimensionalen Arrays untersuchen, indem wir den folgenden Code der Datei hinzufügen:

// Method 1: Declaration with initialization
int matrix[2][3] = {
    {1, 2, 3},   // First row
    {4, 5, 6}    // Second row
};

// Method 2: Partial initialization
int scores[3][3] = {
    {10, 20, 30},
    {40, 50}     // Remaining elements will be zero
};

// Method 3: Flattened initialization
int simple_matrix[2][3] = {1, 2, 3, 4, 5, 6};

Kompilieren und führen Sie das Programm aus, um es zu überprüfen:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Die Beispielausgabe wird eine leere Programmausführung sein, da wir keine Print-Anweisungen hinzugefügt haben.

Wichtige Punkte zur Deklaration von zweidimensionalen Arrays:

• Die erste Klammer repräsentiert die Zeilen.
• Die zweite Klammer repräsentiert die Spalten.
• Sie können das Array teilweise oder vollständig initialisieren.
• Nicht initialisierte Elemente werden automatisch auf Null gesetzt.
• Gesamtzahl der Elemente = Zeilen × Spalten

Initialisieren von zweidimensionalen Arrays

In diesem Schritt lernen Sie verschiedene Methoden zum Initialisieren von zweidimensionalen Arrays in C. Dies baut auf den Deklarationsfähigkeiten aus dem vorherigen Schritt auf.

Lassen Sie uns die vorherige Datei ändern, um verschiedene Initialisierungstechniken zu untersuchen.

Ersetzen Sie nun den vorhandenen Code durch die folgenden Initialisierungsmethoden:

#include <stdio.h>

int main() {
    // Method 1: Complete initialization
    int scores[3][4] = {
        {85, 92, 78, 90},    // First row
        {76, 88, 95, 82},    // Second row
        {63, 71, 89, 93}     // Third row
    };

    // Method 2: Partial initialization
    int temperatures[2][3] = {
        {25, 30, 22},        // First row
        {28}                 // Partial second row
    };

    // Method 3: Flattened initialization
    int matrix[2][3] = {1, 2, 3, 4, 5, 6};

    // Method 4: Initialize all elements to zero
    int zeros[3][3] = {0};

    // Print the first method to demonstrate
    printf("Student Scores:\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", scores[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Beispielausgabe:

Student Scores:
85 92 78 90
76 88 95 82
63 71 89 93

Wichtige Initialisierungsmethoden:

1. Vollständige Initialisierung: Geben Sie Werte für jede Zeile an.
2. Teilweise Initialisierung: Nicht angegebene Elemente werden auf Null gesetzt.
3. Flache Initialisierung: Werte werden zeilenweise gefüllt.
4. Null-Initialisierung: Alle Elemente werden auf Null gesetzt.

Wichtige Punkte:

• Sie können Arrays teilweise initialisieren.
• Nicht angegebene Elemente werden automatisch auf Null gesetzt.
• Die Gesamtzahl der Initialisierer darf die Arraygröße nicht überschreiten.
• Geschachtelte geschweifte Klammern helfen, die zeilenweise Initialisierung zu verdeutlichen.

Zugriff auf Elemente eines zweidimensionalen Arrays

In diesem Schritt lernen Sie, wie Sie auf einzelne Elemente in einem zweidimensionalen Array in C mithilfe von Indizierung und geschachtelten Schleifen zugreifen können.

Lassen Sie uns unsere vorherige Datei aktualisieren, um den Zugriff auf Elemente zu demonstrieren.

Fügen Sie den folgenden Code hinzu, um verschiedene Möglichkeiten des Zugriffs auf Array-Elemente zu untersuchen:

#include <stdio.h>

int main() {
    // Create a 3x4 student grades array
    int grades[3][4] = {
        {85, 92, 78, 90},    // First student's grades
        {76, 88, 95, 82},    // Second student's grades
        {63, 71, 89, 93}     // Third student's grades
    };

    // Method 1: Direct element access
    printf("First student's first grade: %d\n", grades[0][0]);
    printf("Second student's third grade: %d\n", grades[1][2]);

    // Method 2: Accessing elements using nested loops
    printf("\nAll grades using nested loops:\n");
    for (int student = 0; student < 3; student++) {
        for (int subject = 0; subject < 4; subject++) {
            printf("Student %d, Subject %d: %d\n",
                   student + 1, subject + 1, grades[student][subject]);
        }
    }

    // Method 3: Modifying array elements
    grades[2][3] = 95;  // Update last grade of third student
    printf("\nUpdated third student's last grade: %d\n", grades[2][3]);

    return 0;
}

Kompilieren und führen Sie das Programm aus:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Beispielausgabe:

First student's first grade: 85
Second student's third grade: 95

All grades using nested loops:
Student 1, Subject 1: 85
Student 1, Subject 2: 92
Student 1, Subject 3: 78
Student 1, Subject 4: 90
Student 2, Subject 1: 76
Student 2, Subject 2: 88
Student 2, Subject 3: 95
Student 2, Subject 4: 82
Student 3, Subject 1: 63
Student 3, Subject 2: 71
Student 3, Subject 3: 89
Student 3, Subject 4: 95

Updated third student's last grade: 95

Wichtige Punkte zum Zugriff auf Elemente eines zweidimensionalen Arrays:

• Verwenden Sie zwei Indizes: array[Zeile][Spalte]
• Der erste Index repräsentiert die Zeile (vertikal).
• Der zweite Index repräsentiert die Spalte (horizontal).
• Die Indizierung beginnt bei 0.
• Geschachtelte Schleifen sind nützlich, um ganze Arrays zu durchlaufen.
• Sie können direkt einzelne Elemente lesen und ändern.

Berechnung der Durchschnittsnoten für zwei Fächer

In diesem Schritt lernen Sie, wie Sie zweidimensionale Arrays verwenden, um die Durchschnittsnoten für mehrere Schüler in verschiedenen Fächern zu berechnen.

Lassen Sie uns unsere vorherige Datei aktualisieren, um die Fachdurchschnitte zu berechnen.

Fügen Sie den folgenden Code hinzu, um die Durchschnittsnoten zu berechnen und anzuzeigen:

#include <stdio.h>

#define STUDENTS 5
#define SUBJECTS 3

int main() {
    // Create a two-dimensional array for student marks
    int marks[STUDENTS][SUBJECTS] = {
        {85, 92, 78},
        {76, 88, 95},
        {63, 71, 89},
        {90, 84, 77},
        {82, 79, 91}
    };

    // Arrays to store subject averages
    float subject_averages[SUBJECTS];

    // Compute average for each subject
    for (int subject = 0; subject < SUBJECTS; subject++) {
        int subject_total = 0;

        // Sum marks for current subject
        for (int student = 0; student < STUDENTS; student++) {
            subject_total += marks[student][subject];
        }

        // Calculate average
        subject_averages[subject] = (float)subject_total / STUDENTS;
    }

    // Display subject averages
    printf("Subject Averages:\n");
    for (int subject = 0; subject < SUBJECTS; subject++) {
        printf("Subject %d: %.2f\n", subject + 1, subject_averages[subject]);
    }

    // Bonus: Find highest and lowest subject average
    float highest_avg = subject_averages[0];
    float lowest_avg = subject_averages[0];
    int highest_subject = 0;
    int lowest_subject = 0;

    for (int subject = 1; subject < SUBJECTS; subject++) {
        if (subject_averages[subject] > highest_avg) {
            highest_avg = subject_averages[subject];
            highest_subject = subject;
        }
        if (subject_averages[subject] < lowest_avg) {
            lowest_avg = subject_averages[subject];
            lowest_subject = subject;
        }
    }

    printf("\nHighest Average: Subject %d (%.2f)\n",
           highest_subject + 1, highest_avg);
    printf("Lowest Average: Subject %d (%.2f)\n",
           lowest_subject + 1, lowest_avg);

    return 0;
}

Kompilieren und führen Sie das Programm aus:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Beispielausgabe:

Subject Averages:
Subject 1: 79.20
Subject 2: 82.80
Subject 3: 86.00

Highest Average: Subject 3 (86.00)
Lowest Average: Subject 1 (79.20)

Dargestellte Schlüsselkonzepte:

• Verwendung von geschachtelten Schleifen zur Verarbeitung von zweidimensionalen Arrays
• Berechnung von Durchschnitten über Zeilen und Spalten
• Finden der höchsten und niedrigsten Durchschnitte
• Typumwandlung zur Berechnung von Fließkommadurchschnitten
• Definition von Konstanten für die Array-Dimensionen

Verbesserung der Funktionalität von zweidimensionalen Arrays

In diesem letzten Schritt lernen Sie fortgeschrittene Techniken zur Verbesserung der Funktionalität von zweidimensionalen Arrays kennen, einschließlich des Übergebens von Arrays an Funktionen, der dynamischen Speicherzuweisung und der Erstellung komplexerer Array-Operationen.

Lassen Sie uns unsere vorherige Datei aktualisieren, um diese fortgeschrittenen Konzepte zu demonstrieren.

Ersetzen Sie den vorherigen Code durch dieses umfassende Beispiel:

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

#define ROWS 3
#define COLS 4

// Function to print a two-dimensional array
void printArray(int arr[ROWS][COLS]) {
    printf("Array Contents:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", arr[i][j]);
        }
        printf("\n");
    }
}

// Function to transpose a two-dimensional array
void transposeArray(int original[ROWS][COLS], int transposed[COLS][ROWS]) {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            transposed[j][i] = original[i][j];
        }
    }
}

int main() {
    // Static two-dimensional array
    int matrix[ROWS][COLS] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // Print original array
    printf("Original Array:\n");
    printArray(matrix);

    // Transpose the array
    int transposed[COLS][ROWS];
    transposeArray(matrix, transposed);

    // Print transposed array
    printf("\nTransposed Array:\n");
    for (int i = 0; i < COLS; i++) {
        for (int j = 0; j < ROWS; j++) {
            printf("%4d ", transposed[i][j]);
        }
        printf("\n");
    }

    // Dynamic memory allocation for 2D array
    int **dynamicMatrix;
    dynamicMatrix = (int **)malloc(ROWS * sizeof(int *));
    for (int i = 0; i < ROWS; i++) {
        dynamicMatrix[i] = (int *)malloc(COLS * sizeof(int));
    }

    // Initialize dynamic matrix
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            dynamicMatrix[i][j] = i * COLS + j + 1;
        }
    }

    // Print dynamic matrix
    printf("\nDynamic Matrix:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%4d ", dynamicMatrix[i][j]);
        }
        printf("\n");
    }

    // Free dynamically allocated memory
    for (int i = 0; i < ROWS; i++) {
        free(dynamicMatrix[i]);
    }
    free(dynamicMatrix);

    return 0;
}

Kompilieren und führen Sie das Programm aus:

gcc two_dimensional_arrays.c -o two_dimensional_arrays
./two_dimensional_arrays

Beispielausgabe:

Original Array:
   1   2   3   4
   5   6   7   8
   9  10  11  12

Transposed Array:
   1   5   9
   2   6  10
   3   7  11
   4   8  12

Dynamic Matrix:
   1   2   3   4
   5   6   7   8
   9  10  11  12

Dargestellte Schlüsselkonzepte:

• Übergeben von zweidimensionalen Arrays an Funktionen
• Transponieren von Arrays
• Dynamische Speicherzuweisung für zweidimensionale Arrays
• Speicherverwaltung mit malloc() und free()
• Flexible Array-Manipulationstechniken

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in C zweidimensionale Arrays deklarieren können. Zweidimensionale Arrays sind Arrays von Arrays, die es Ihnen ermöglichen, Daten in einer gitterartigen Struktur mit Zeilen und Spalten zu speichern. Sie haben verschiedene Methoden zur Deklaration und Initialisierung von zweidimensionalen Arrays untersucht, darunter die vollständige Initialisierung, die teilweise Initialisierung und die flache Initialisierung. Sie haben auch gelernt, dass nicht initialisierte Elemente automatisch auf Null gesetzt werden und dass die Gesamtzahl der Elemente in einem zweidimensionalen Array durch das Produkt aus der Anzahl der Zeilen und Spalten bestimmt wird.

Basierend auf Ihren Deklarationsfähigkeiten haben Sie dann verschiedene Methoden zum Initialisieren von zweidimensionalen Arrays in C gelernt, einschließlich der Zuweisung von Werten zeilenweise, spaltenweise oder unter Verwendung eines flachen Ansatzes. Sie haben auch untersucht, wie Sie auf einzelne Elemente innerhalb des zweidimensionalen Arrays mithilfe von Zeilen- und Spaltenindizes zugreifen können.