2d Array in C

6 Key excerpts on "2d Array in C"

• 

  eBook - ePub

  C Programming

  A Self-Teaching Introduction

  • Rajiv Chopra(Author)
  • 2017(Publication Date)
  • Mercury Learning and Information

    (Publisher)

  A two-dimensional array is basically a collection of similar types of elements which are organized in two dimensions. They are used to represent a table with rows and columns. Real-life examples of 2d arrays include chess boards, tic-tac-toe boards, and so on.

  How to Declare 2d Arrays in C

  Declaring a 2d array uses the following syntax:       datatype arrayname [m][n];

  Here, arrayname is the name of a two-dimensional array that contains the elements of the datatype mentioned and has ‘m’ number of rows and ‘n’ number of columns. For example,

  int a[10][20]; It declares that ‘a’ is a two-dimensional array with dimensions of (10 * 20).

  How to Access 2d Arrays in C

  An individual data item of a 2D array is accessed by specifying the row and column of a 2d array as follows:    a[i] [j]; where ‘i’ refers to the row number and ‘j’ refers to the column number.

  For example, a[1][2] refers to the data item in the 2nd row and 3rd column (noting that indexing in C starts from 0).

  How to Read Elements into a 2d Array in C

  We read in the values of 2d arrays by using two nested for loops as follows:

  for(i=0; i<m; i++) { for(j=0;j<n;j++) scanf(“%d”, &num[i][j]); }

  How to Display Elements from a 2d Array in C

  We use nested loops to display the array elements (i.e., one for the row and one for the column) as follows:

  for(i=0; i<m; i++) { for(j=0;j<n;j++) printf(“%d\n”, num[i][j]); }

  How to Initialize a 2d Array in C

  Like a 1d array, we can also initialize a 2d array during its declaration as follows:

  int a[3][4] = { {10, 20, 30, 40}, {50, 60, 70, 80}, {90, 100, 110, 120} };

  We can also initialize it as follows in a single line: int a[3][4] = {10,20,30,40,50,60,70,80,90,100,110,120};

  Please note that when we initialize 2d arrays, the declaration of the first dimension (row) is optional but the second dimension (column) declaration is compulsory. Also note that the user has to explicitly mention size of column during the initialization of a 2d array.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  C Programming

  Learn to Code

  • Sisir Kumar Jena(Author)
  • 2021(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  a multidimensional array. In this section, we will discuss the 2D array.

  In the 2D array, we require two subscripts to indicate one element. One subscript denotes the row number and the other subscript denotes the column number. Like 1D arrays, the subscript value starts from 0 (zero). Figure 10.11 shows an example to denote an element in a 2D array.

  Figure 10.11 An element of a 2D array with two subscripts.

  10.5.1 Introducing Matrices

  A matrix mat[m][n] is an m by n table having m rows and n columns containing m × n elements (refer to Figure 10.12 ). Each element of the matrix is represented by mat[i][j].

  Figure 10.12 A matrix.

  where,

  i represents the row number and varies from i = 0, 1, 2, …, m − 1

  j represents the column number and varies from j = 0, 1, 2, …, n − 1

  10.5.2 Declaration of a 2D Array

  We use a general form shown in (Figure 10.13 ) to declare a 2D array.

  Figure 10.13 Syntax of a 2D array declaration and example.

  The example code (Figure 10.13b) will create an array of integers named Mat and can store 4 x 3 = 12 elements of integer type. The element of the array can be accessed by Mat[0][0], Mat[0][1]. . . . . Mat[2][3] and so on. According to its characteristics, all the elements of the matrix will be stored in contiguous memory locations.

  10.5.3 Representation of a 2D Array in Memory

  Since we know that array elements will be stored in contiguous memory locations, the 2D array is also stored in contiguous memory locations. In memory, whether a 1D or a 2D array, the array elements are stored in one continuous chain.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Data Structures and Program Design Using Java

  A Self-Teaching Introduction

  • D. Malhotra, N. Malhotra(Authors)
  • 2020(Publication Date)
  • Mercury Learning and Information

    (Publisher)

  We have already discussed 1-D arrays/one-dimensional arrays and their various types and operations. Now, we will learn about two-dimensional arrays. Unlike one-dimensional arrays, 2-D arrays are organized in the form of grids or tables. They are a collection of 1-D arrays. One-dimensional arrays are linearly organized in the memory. A 2-D array consists of two subscripts:

  1. first subscript: which denotes the row
  2. second subscript: which denotes the column

  A 2-D array is represented as shown in the following figure:

  Figure 3.5. Representation of a 2-D array.

  3.8  Declaration of Two-Dimensional Arrays

  As we declared 1-D arrays, similarly we can declare two-dimensional arrays. For declaring two-dimensional arrays, we must know the name of the array, the data type of each element, and the size of each dimension (size of rows and columns).

  Syntax:

  data_type[][] array_name = new int [row_size] [column_size];

  A two-dimensional array is also called an m X n array, as it contains m X n elements where each element in the array can be accessed by i and j, where i<=m and j<=n, and where i, j, m, n are defined as follows:

  i, j = subscripts of array elements, m = number of rows, n = number of columns.

  For example: Let us take an array of 3 X 3 elements. Therefore, the array is declared as:

  int marks [3] [3];

  In the previous diagram the array has three rows and three columns. The first element in the array is denoted by marks [0] [0] . Similarly, the second element will be denoted by marks [0] [1] , and so on. Also, data elements in an array can be stored in the memory in two ways:

  Row Major Order

  In row major order the elements of the first row are stored before the elements of the second, third, and n rows. Here the data elements are stored on a row-by-row basis:

  Column Major Order

  In column major order the elements of the first column are stored before the elements of the second, third, and n columns. Here the data elements are stored on a column-by-column basis:

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  C

  From Theory to Practice, Second Edition

  • George S. Tselikis, Nikolaos D. Tselikas(Authors)
  • 2017(Publication Date)
  • CRC Press

    (Publisher)

  stay away from betting sites that advertise big profits in online lotteries. The big profits they promise are not for you, but for their owners.

  Two-Dimensional Arrays

  The form of a two-dimensional array resembles that of a matrix in math; it is an array of elements of the same type arranged in rows and columns. As with one-dimensional arrays, we’ll use arithmetic types in our examples. In the following chapters, you’ll see more application examples. Besides numbers, a two-dimensional array is often used to store strings; you’ll see this application in Chapter 10 .

  Declaring Arrays

  To declare a two-dimensional array, we must specify its name, its data type, and the number of its rows and columns, like this:

  data_type array_name[number_of_rows][number_of_columns]

  The number of its elements is equal to the product of rows multiplied by columns. For example, the statement double arr[10][5]; declares the two-dimensional array arr with 50 elements of type double .

  Accessing Array Elements

  To access an element, we write the name of the array followed by the element’s row index and column index enclosed in double brackets. As with one-dimensional arrays, the indexing of rows and columns starts from 0 . For example, the statement:

  int a[3][4];

  declares a two-dimensional array, whose elements are the a[0][0] , a[0][1] , … a[2][3] , as shown in Figure 7.1 .

  Figure 7.1

  Two-dimensional array (3 × 4).

  Although a two-dimensional array is visualized as an array with rows and columns, its elements are stored in consecutive memory locations in row-major order, with the elements of row 0 first, followed by the elements of row 1, and so on.

  Although we refer to multidimensional arrays, C supports only one-dimensional arrays. Because an element of an array may be another array, we can simulate multidimensional arrays.

  For example, the elements of the a array are the a[0] , a[1] , and a[2] , where each one of them is an array of four integers. We’ll analyze it more in Chapter 8 , when discussing about pointers and two-dimensional arrays. Also, we’ll see in C.8.39 how we can treat a two-dimensional array as if it were one-dimensional. In another example, if we write int a[3][4][5]; a

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  ANSI C Programming

  Learn ANSI C step by step

  • Yashavant Kanetkar(Author)
  • 2020(Publication Date)
  • BPB Publications

    (Publisher)

  stud[0][1] and so on. The above arrangement highlights the fact that a two- dimensional array is nothing but a collection of a number of one- dimensional arrays placed one below the other.

  In our sample program, the array elements have been stored row-wise and accessed row- wise. However, you can access the array elements column-wise as well. Traditionally, the array elements are being stored and accessed row-wise; therefore we would also stick to the same strategy.

  Initialising a 2-Dimensional Array

  How do we initialize a two-dimensional array? As simple as this…

  or even this would work… int stud[4][2] = { 1234, 56, 1212, 33, 1434, 80, 1312, 78 }; of course, with a corresponding loss in readability. It is important to remember that, while initializing a 2-D array, it is necessary to mention the second (column) dimension, whereas the first dimension (row) is optional. Thus the declarations, int arr[2][3] = { 12, 34, 23, 45, 56, 45 }; int arr[ ][3] = { 12, 34, 23, 45, 56, 45 }; are perfectly acceptable, whereas, int arr[2][ ] = { 12, 34, 23, 45, 56, 45 }; int arr[ ][ ] = { 12, 34, 23, 45, 56, 45 }; would never work.

  Memory Map of a 2-Dimensional Array

  Let us reiterate the arrangement of array elements in a two-dimensional array of students, which contains roll nos. in one column and the marks in the other.

  The array arrangement shown in Figure 10.4 is only conceptually true. This is because memory doesn’t contain rows and columns. In memory, whether it is a one-dimensional or a two-dimensional array, the array elements are stored in one continuous chain. The arrangement of array elements of a two-dimensional array in memory is shown below:

  Figure 10.5 We can easily refer to the marks obtained by the third student using the subscript notation as shown below: printf ("Marks of third student = %d", stud[2][1]); Can we not refer to the same element using pointer notation, the way we did in one- dimensional arrays? Answer is yes. Only the procedure is slightly difficult to understand. So, read on…

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Learn Programming with C

  An Easy Step-by-Step Self-Practice Book for Learning C

  • Sazzad M.S. Imran, Md Atiqur Rahman Ahad(Authors)
  • 2024(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  When any array is declared, the array is organized such that all the array elements occupy contiguous space in memory. If the size of the integer data type is 4 bytes, then the memory organization of the array num[4] is as follows:

  3.2 2D ARRAYS

  A two-dimensional array is an array of arrays. It is also known as a matrix in C and is defined as a set of rows and columns. The following expression represents an integer type 2D array of matrix 2 × 4.

  int num[2][4]; When declaring or initializing a 2D array, we must specify the size of the second dimension or the number of columns. The 2D array items are initialized as follows:

  1. int num[2][4] = { {5, 10, 9, 19}, {6, 3, 12, 23}};
  2. int num[][4] = {{5, 10, 9, 19}, {6, 3, 12, 23}};
  3. int num[][4] = {5, 10, 9, 19, 6, 3, 12, 23};
  4. int i, j, num[2][4]; for (i=0; i<2; i++) for (j=0; j<4; j++) scanf(“%d”, &num[i][j]);

  The conceptual memory organization of the 2D array num[3][4] is as follows:

  3.3 MULTIDIMENSIONAL ARRAYS

  The simplest version of multidimensional arrays used in C is 2D arrays discussed earlier. Similar to 2D arrays, 3D arrays are declared as int multi[2][3][4]; where multi is a three-dimensional array with 24 entries. Three-dimensional array is initialized as follows: int multi[2][3][4] = { {{1, 2, 3, 4}, {5, 7, 9, 11}, {−3, 13, 23, 31}}, {{2, 4, 6, 8}, {6, 7, −8, 9}, {4, 12, 23, −3}}}; The 24 elements of the 3D array can be entered as follows from a standard input terminal: int i, j, k; for (i=0; i<2; i++) for (j=0; j<3; j++) for (k=0; k<4; k++) scanf(“%d”, &multi[i][j][k]); The 24 elements of the 3D array can be displayed on the screen as follows: int i, j, k; for (i=0; i<2; i++) for (j=0; j<3; j++) for (k=0; k<4; k++) printf(“multi[%d][%d][%d]=%d\n”, i, j, k, multi[i][j][k]);

  3.4 STRING

  A string is a series of characters that end with the null terminator ‘\0’. As an example, a string is declared as follows:

  Sign up to read

  Learn more about book