CS140 Lecture notes -- Types, Pointers

Types in C

Scalar Types

These should all be familiar to you. You can declare a scalar variable in one of three places: As a global variable, as a procedure parameter, and as a local variable. For example, look at the program below in p1.c:

(In this and all other lecture notes, you can copy the programs and the makefile into your own directory, and then compile them by using make. E.g. to make the program p1, you say ``make p1'').

#include < stdio.h >

int i;

main(int argc, char **argv)
{
  int j;

  j = argc;
  i = j;
  printf("%d\n", i);
}

Aggregate Types

You can statically declare an array as a global or local variable. I.e.:

#include < stdio.h >

char s1[15];

main(int argc, char **argv)
{
  char s2[4];
  
}

If an array has been statically declared, then you cannot assign it to another array, even if the two arrays have the same type and the same number of elements. For example, look at p2.c:

#include < stdio.h >

char s1[4];

main(int argc, char **argv)
{
  char s2[4];
  
  s2 = "Jim";
  s2 = s1;
}

UNIX> gcc -o p2 p2.c
p2.c: In function `main':
p2.c:9: incompatible types in assignment
p2.c:10: incompatible types in assignment

UNIX>

Like arrays, structs can be declared as either local variables or global variables. Unlike arrays, one struct can be assigned to another struct as long as the two struct have the same type. For example, check out paycheck.c:

#include < stdio.h >

struct paycheck {
    double gross_pay;
    double taxes;
};

struct paycheck brad;

main(int argc, char **argv)
{
    struct paycheck sue;

    brad.gross_pay = 50000.00;
    brad.taxes = brad.gross_pay * .3;

    sue = brad;

    printf("sue's gross_pay is $%8.2lf\n", sue.gross_pay);
    printf("sue's taxes are $%8.2lf\n", sue.taxes);
}

Pointers

You can view memory as one huge array of bytes (chars). This array has 2147483648 (or some other huge number) elements. Usually, we consider the indices to this array in hexidecimal. In other words, the array goes from 0x0 to 0x7fffffff.

A pointer is simply an index of this array. Whenever we allocate x bytes of memory, we are reserving x contiguous elements from the memory array. If we set a pointer to these bytes, then that pointer will be the index of the first allocated byte in memory.

For example, look at the following program (in p3.c):

main()
{
  int i;
  char j[14];
  int *ip;
  char *jp;
  int **ipp;

  ip = &i;
  ipp = &ip;
  jp = j; 

  printf("ip = 0x%x.  jp = 0x%x.  ipp = 0x%x\n", ip, jp, ipp);
  printf("&ip = 0x%x.  &jp = 0x%x.  &ipp = 0x%x\n", &ip, &jp, &ipp);
  printf("\n");

  i = 4;
  printf("i = %d\n", i);
  printf("ip = 0x%x, *ip = %d\n", ip, *ip);
  printf("ipp = 0x%x, *ipp = 0x%x, **ipp = %d\n", ipp, *ipp, **ipp);
  printf("\n");

  *ip = 3;
  printf("i = %d\n", i);
  printf("ip = 0x%x, *ip = %d\n", ip, *ip);
  printf("ipp = 0x%x, *ipp = 0x%x, **ipp = %d\n", ipp, *ipp, **ipp);
  printf("\n");

}

Note that even though we haven't set any values for i or j, we can still print their addresses.

When we run p3 the first line is something like (note, these values will differ from machine to machine, so if you run p3, you will likely get different values. However, the interrelationship between these values should remain the same):

ip = 0xefffe54c.  jp = 0xefffe538.  ipp = 0xefffe534

        ...   |              |
   0xefffe52c |              |
   0xefffe530 |              |
   0xefffe534 |     ip       |
   0xefffe538 | j[0] - j[3]  |
   0xefffe53c | j[4] - j[7]  |
   0xefffe540 | j[8] - j[11] |
   0xefffe544 | j[12] - j[13]|
   0xefffe548 |              |
   0xefffe54c |      i       |
        ...   |              |

Note all of these facts are reflected in the little picture of memory. The next line prints the addresses of ip, jp and ipp:

&ip = 0xefffe534.  &jp = 0xefffe530.  &ipp = 0xefffe52c

        ...   |              |
   0xefffe52c |ipp=0xefffe534|
   0xefffe530 |jp= 0xefffe538|
   0xefffe534 |ip= 0xefffe54c|
   0xefffe538 | j[0] - j[3]  |
   0xefffe53c | j[4] - j[7]  |
   0xefffe540 | j[8] - j[11] |
   0xefffe544 | j[12] - j[13]|
   0xefffe548 |              |
   0xefffe54c |      i       |
        ...   |              |

Now, the next thing that program p3 does is set i to four, and then print out i, ip, *ip, ipp, *ipp and **ipp:

i = 4
ip = 0xefffe54c, *ip = 4
ipp = 0xefffe534, *ipp = 0xefffe54c, **ipp = 4

        ...   |              |
   0xefffe52c |ipp=0xefffe534|
   0xefffe530 |jp= 0xefffe538|
   0xefffe534 |ip=0xefffe54c |---\
   0xefffe538 | j[0] - j[3]  |   |
   0xefffe53c | j[4] - j[7]  |   |
   0xefffe540 | j[8] - j[11] |   |
   0xefffe544 | j[12] - j[13]|   |
   0xefffe548 |              |   |
   0xefffe54c |     i = 4    |<--/
        ...   |              |

Now, finally we set *ip to 3. This makes memory look like:

        ...   |              |
   0xefffe52c |ipp=0xefffe534|
   0xefffe530 |jp= 0xefffe538|
   0xefffe534 |ip=0xefffe54c |---\
   0xefffe538 | j[0] - j[3]  |   |
   0xefffe53c | j[4] - j[7]  |   |
   0xefffe540 | j[8] - j[11] |   |
   0xefffe544 | j[12] - j[13]|   |
   0xefffe548 |              |   |
   0xefffe54c |     i = 3    |<--/
        ...   |              |

i = 3
ip = 0xefffe54c, *ip = 3
ipp = 0xefffe534, *ipp = 0xefffe54c, **ipp = 3

Other things: Note that in p3.c, I said ``jp = j'' and not ``jp = &j''. This is because when treated as an expression, an array is equivalent to a pointer. The only difference is that you cannot assign a value to an array variable. Thus, you can say ``jp = j'', but you cannot say ``j = jp''. Moreover, you cannot take the address of an array variable -- saying ``&j'' is illegal.

Pointers are a little like scalars -- they too can be declared as globals, locals or parameters, and can be assigned values, passed as parameters, and returned from procedures. On our machines all pointers are 4 bytes. Thus, in p3.c, there are 30 bytes of local variables allocated in the main() procedure -- 4 for i, 14 for j, 4 for ip, 4 for jp, and 4 for ipp.

Segmentation Violations and Bus Errors

The program pa.c generates a segmentation violation by trying to dereference NULL:

#include < stdio.h >

main()
{
  char *s;

  s = NULL;

  printf("%d\n", s[0]);
}

main()
{
  int *i;

  i = (int *) 1;

  printf("%d\n", *i);
}

Where does memory come from?

1. As a global variable.
2. As a local variable or parameter in a procedure call.
3. From malloc().

int i;

main(int argc, char **argv)
{
  int j;

  j = argc;
  i = j;
  printf("%d\n", i);
}

• 4 bytes come from the global variable i.
• 4 bytes come from the local variable j.
• 4 bytes come from the parameter argc.
• 4 bytes come from the parameter argv.

Global variables can be accessed anytime, anywhere. They are allocated by the operating system when the program starts. We will not use global variables in this class. The reason is that there is a place for global variables, but it isn't in the programs that you all will write. The only thing that global variables will do is make your code harder to read, and probably more buggy.

What's an example of a reasonable global variable? When you say:

  fprintf(stderr, "something\n");

The memory allocated for local variables and parameters can be accessed only while their defining procedure is running. This is convenient, because usually you don't want it otherwise. For example, look at pc.c:

a(int n)
{
  int total;

  total = 0;
  while (n > 0) {
    total += n;
    n--;
  }
  return total;
}
    
  
main(int argc, char **argv)
{
  int i;

  i = a(3);
  printf("%d\n", i);
}

So what does it mean when I say: ``local variables and parameters can be accessed only while their defining procedure is running?'' Look at pd.c:

char *read_word()
{
  char s[200];

  if (scanf("%s", s) != 1) return NULL;

  return s;

}
    
  
main(int argc, char **argv)
{
  char *strings[10];
  int i;

  for (i = 0; i < 10; i++) {
    strings[i] = read_word();
    if (strings[i] == NULL) exit(1);
  }

  for (i = 0; i < 10; i++) {
    printf("%d %s\n", i, strings[i]);
  }

}