Two-Dimensional Numeric and character Array: declaration, initialization

2D array दो indexes वाला एक grid है, पहले rows फिर columns (marks[student][subject]), braces के अंदर braces से initialize होता और उन्हीं nested loops से चला जाता है जो आपके पास पहले से हैं।

11 min read · 10 cards · 2 checks

Read in: English · हिन्दी · ગુજરાતી


Theory

एक student एक line था; एक class एक grid है

Marks array ने हर student का एक number रखा। हक़ीक़त: हर student के 4 subjects हैं।

60 students × 4 subjects boxes की एक line नहीं है, यह एक grid है: rows और columns, ठीक वह marksheet जो teacher noticeboard पर लगाता है।

C किसी array को एक दूसरा index देकर grids बनाता है:

int marks[3][4]; /* 3 students, 4 subjects */

अगर इसमें BCA102 की matrices की महक आती है, तो अपनी नाक पर भरोसा कीजिए, वही grid, अब code में।

Theory

Cinema hall

एक cinema ticket कभी "seat 47" नहीं कहता; वह कहता है row F, seat 9: पहले row, फिर उसके अंदर seat। एक 2D array cinema hall है: marks[1][2] का मतलब है row 1, seat 2 (दोनों zero से गिने)। BCA102 का RC नियम अछूता बचता है: पहले Rows, फिर Columns, एक RC car की तरह, और अब यह आपके code को चलाता है।

Theory

Declaration और initialization

  • Declare: int marks[3][4]; 3 × 4 = 12 int boxes reserve करता है।
  • Initialize, braces के अंदर braces (हर row के लिए एक inner brace):

int marks[2][3] = {

{70, 80, 90}, /* student 0 */

{60, 75, 85} /* student 1 */

};

  • Access: marks[1][2] student 1 (दूसरा), subject 2 (तीसरा) है: 85।

Memory में grid row-दर-row store होता है (row-major): पहले row 0 के सारे boxes, फिर row 1 के, grid का चश्मा पहने एक लंबी line।

Practical

Nested loops से grid पर चलना

#include <stdio.h>

int main() {
    int marks[2][3] = {{70, 80, 90}, {60, 75, 85}};
    int i, j;

    for (i = 0; i < 2; i++) {          /* each student (row) */
        printf("Student %d: ", i);
        for (j = 0; j < 3; j++)        /* each subject (col) */
            printf("%d ", marks[i][j]);
        printf("\n");
    }
    return 0;
}

This example runs in Gri-Learn on the web, where you can edit it and see the output.

Think first

Grid पढ़िए

int marks[2][3] = {{70, 80, 90}, {60, 75, 85}}; इस्तेमाल करके निकालिए: marks[0][1], marks[1][0], और marks[1][2]। पहले rows, zero से।

Show the answer

marks[0][1] = 80 (पहला student, दूसरा subject)। marks[1][0] = 60 (दूसरा student, पहला subject)। marks[1][2] = 85 (दूसरा student, तीसरा subject)।

अगर आपने 60 और 80 उलट दिए, तो आपने column-पहले पढ़ा, सबसे आम 2D चूक। Ticket नियम: row, फिर seat।

Quiz

int marks[4][5] कितने int boxes reserve करता है, और आख़िरी valid element कौन सा है?

  1. 20 boxes; आख़िरी marks[3][4] है
  2. 20 boxes; आख़िरी marks[4][5] है
  3. 9 boxes; आख़िरी marks[3][4] है
  4. 20 boxes; आख़िरी marks[4][4] है
Show the answer

20 boxes; आख़िरी marks[3][4] है

कुल = rows × columns = 4 × 5 = 20। दोनों indexes zero से शुरू होते हैं, तो वे rows-1 और cols-1 पर खत्म होते हैं: marks[3][4]। marks[4][5] को element के रूप में लिखना एक साथ दो dimensions में out-of-bounds पाप करता है। Size गुणा होता है; आख़िरी index हर एक में से एक घटाता है, दो नियम, एक सवाल।

Theory

characters का एक grid: names की एक list

Rows text भी रख सकती हैं:

char names[3][10] = {"Riya", "Aman", "Zoya"};

हर ROW एक char array है: 9 तक letters और अपना '\0'। तो names[1] पूरी string "Aman" है, और names[1][0] letter 'A' है।

एक index string चुनता है, दो indexes letter चुनते हैं, marks program आख़िरकार store कर सकता है कि किसने क्या score किया, names और numbers अगल-बगल।

Watch out

Marks कहाँ कटते हैं

Column-पहले पढ़ना: marks[i][j] row i, column j है, हमेशा; उन्हें उलटिए और हर जवाब transpose हो जाता है। Comma indexing: marks[1, 2] C में compile होता है पर इसका मतलब row 1 column 2 नहीं है (चुपचाप इसका मतलब marks[2] होता है, एक असली trap); हमेशा marks[1][2] लिखिए। दोनों dimensions में bounds: rows-1 और cols-1 सिरे हैं। और एक char 2D array की हर row को अपना '\0' space चाहिए।

Theory

BCA102 अपना फल देता है

आप इस grid का गणित पहले से जानते हैं: order m×n, aᵢⱼ addressing, BCA102 के matrix lessons। अगला lesson उस गणित को C में बदलता है: दो marks grids जोड़ना, transpose करना, यहाँ तक कि matrix multiplication, सब 2D arrays पर nested loops। आपके दो subjects अभी एक ही skill में मिल गए।

Summary

Key takeaways

  • int marks[3][4]: 3 rows × 4 columns = 12 boxes; पहले rows, फिर columns।
  • दोनों indexes zero से शुरू; आख़िरी element [rows-1][cols-1] है।
  • braces के अंदर braces से initialize कीजिए, हर row के लिए एक inner brace।
  • Nested loops से grids पर चलिए: outer i = rows, inner j = columns।
  • char names[3][10]: तीन strings, हर row अपने '\0' के साथ।
  • कभी comma से index मत कीजिए: marks[1][2], न कि marks[1, 2]।
  • याद रखने का hook: cinema ticket, पहले row, फिर seat।

Study this properly

This page is the lesson to read. In Gri-Learn the same topic is a graded deck: the self-checks are scored and your weak topics are tracked. Free to start.

Start this topic

Already have an account? Sign in

More from Concepts of Arrays and Pointer

Gri-Learn · syllabus-mapped B.C.A. lessons in English, Hindi and Gujarati

Two-Dimensional Numeric and character Array: declaration, initialization · Computer Programming and Programming Methodology (CPPM) · Gri-Learn