c programming arrays by laishramindie2034

VIEWS: 13 PAGES: 11

									       C Arrays: 1D & 2D 


ENGG1002 Computer Programming and 
            Applica9ons 
      Dr. Hayden Kwok‐Hay So 
              Week 1 
                       Basic C Arrays 
  Declara9on:                int anarray[5];


               data type          variable 
           of each element                    size 
                                   name 
  Ini9aliza9on (op9onal) 
        int anarray[5] = {2,3,5,7,11};

  Accessing an element 
   •  Remember: C/C++ arrays start coun9ng from 0! 
   •  Valid for indexes from 0 to size‐1 
        anarray[0] = 31;

        anarray[i+3] = anarray[4]+7;

  What happens when you access anarray[6]? 
                       Array vs Memory 
  The main memory of a computer can be thought as a huge 
   array of memory loca9ons. 
   •  Each basic memory loca9on consumes 1 BYTE. 
   •  E.g. The 1GB of main memory can be thought as an array with 
      1,073,741,824  elements, each element = 1 BYTE. 
  In C/C++, an array is a con(nuous block of memory. 
 1,073,741,823             char vowels[5]={‘a’,’e’,’i’,’o’,’u’};

 1,073,741,822 
                  u 
                  o        1 bytes 
                  i 
                  e 
                  a            vowels

             1 
             0 
                 Array of Integers 
             int primes[3]={11,13,17};


                          Q: If primes is stored at loca9on 
108                        100, then how can you find 
107 
106 
                           primes[1], primes[2]? 
       13 




105                       A: primes[1] stored at loca9on 
104                        100 + 4 = 104 
103                        primes[2] at loca9on  
102 
                           100 + 2*4 = 108 
       11 




             4 bytes 
101 
100                       Element k at 100 + k * 4 
                          The size of an integer is 4 bytes 
  1          primes

                          In C, you can use the func9on 
  0 
                           sizeof(), e.g.

                           sizeof(int), sizeof(i); 
                 Array Addressing 
  In general, given you know the star9ng address 
   (A) of an array of type T, you can find the k‐th 
   element at address 
   A + k * sizeof(T) 
  To be able to find the loca9on of an array 
   element V[k], the compiler only needs to know 
   the type of the element and the star(ng 
   address. 
  C/C++ compilers do not know about the “length” 
   of an array. 
  •  It only generates code to calculate the address of an 
     element based on the above equa9on 
                    Basic 2D Arrays 

  Declara9on:              int a2Darray[5][7];


             data type           variable 
         of each element                     Sizes of the 2 
                                  name 
                                              dimensions 

  Ini9aliza9on (op9onal) 
    int a2Darray[2][3] = {{2,3,5},{7,11,13}};


  Accessing an element 
       a2Darray[0][2] = 31;

       cout << a2Darray[i+3][j+2];

                        2D Arrays 
  How to store a 2D array (matrix) in memory that is a 
   linear (1D) array? 
  Two methods: 
   •  Row‐major – stores a 2D array (matrix) row‐by‐row, 
      star9ng from top to bolom. 
   •  Column major – stores a matrix column‐by‐column, 
      star9ng from lem to right. 

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

   9    10  11  12 

  C/C++ stores them in row‐major 
  Matlab stores them in column‐major 
                   2D arrays in C/C++ 
                                 1    2    3    4 
                         V =
    5    6    7    8 
136    10 
                                 9    10  11  12 
132    9 
128    8 
124    7                  To access an element in a 2D array V 
120    6                   V[0][1] => 2, V[2][1] => 10 
116    5     4 bytes      What do you need to find the address? 
112    4                   •  V[0][1] @ address(V) + 1 * sizeof(int) 
108    3                   •  V[2][1] @ address(V) + 2 * 4 *  sizeof(int) + 
104    2                      1 * sizeof(int)  
100    1 
                          We need three pieces of informa9on: 
 4           V

                           •  address(V) 
 0 
                           •  Size of the element 
                           •  The length of a row 
              Gerng Memory for Arrays 
  Sta9c: int primes[5] = {2,3,5,7,11};

  Dynamic: 
   •  When you don’t know the size when you write your program 
          E.g. To put all the customer orders in an array 
   •  Use malloc() 
  int num_orders;

  int orders[];

  orders = (int*) malloc(num_orders * sizeof(int));  

  C++ has some extra syntax 
   •  Dangerous, not recommended! 
  int  num_orders;

  int  orders[num_orders];

  cin  >> num_orders;

  for  (int i = 0; i < num_orders; i++)

      orders[0] = . . . 
                Arrays as Parameters 
  To accept an 1D array as parameter: 
   int func(int a[], int length);

  Note that we have no idea of the length of a[].  
   Therefore, we must, somehow, send the length to the 
   func9on as well. 
   •  One way is to pass the length as well. 
   •  Another way is to use a struct. 
  To accept a 2D array as parameter: 
   int func(int b[][10], int length); 
  Note that all dimensions, except the first, MUST be 
   defined. 
   •  Why? (Recall how you can get the address of an element in 
      a mul9‐dimensional array.) 
           2D Array for the Project 

  Func9ons for reading images from your file 
   system will be provided 
  Image stored as a 2D array 
  Memory will be allocated dynamically for you 
   already. 
  You need to implement the image processing 
   rou9nes on the 2D array. 

								
To top