Web | This Site

Learning C
C Function References
C Useful Resources
Selected Reading
© 2011 TutorialsPoint.COM

| Home |  | References |  | About TP |  | Advertising

# C - Useful Concepts

# Error Reporting:

Many times it is useful to report errors in a C program. The standard library perror() is an easy to use and convenient function. It is used in conjunction with errno and frequently on encountering an error you may wish to terminate your program early. We will meet these concepts in other parts of the function reference chapter also.

- void perror(const char *message) - produces a message on standard error output describing the last error encountered.

errno: - is a special system variable that is set if a system call cannot perform its set task. It is defined in #include <errno.h>.

# Predefined Streams:

UNIX defines 3 predefined streams ie. virtual files

    stdin,  stdout,  stderr

They all use text a the method of I/O. stdin and stdout can be used with files, programs, I/O devices such as keyboard, console, etc.. stderr always goes to the console or screen.

The console is the default for stdout and stderr. The keyboard is the default for stdin.

# Dynamic Memory Allocation:

Dynamic allocation is a pretty unique feature to C. It enables us to create data types and structures of any size and length to suit our programs need within the program. We use dynamic memory allocation concept when we don't know how in advance about memory requirement.

There are following functions to use for dynamic memory manipulation:

- void *calloc(size_t num elems, size_t elem_size) - Allocate an array and initialise all elements to zero .

- void free(void *mem address) - Free a block of memory.

- void *malloc(size_t num bytes) - Allocate a block of memory.

- void *realloc(void *mem address, size_t newsize) - Reallocate (adjust size) a block of memory.

# Command Line Arguments:

It is possible to pass arguments to C programs when they are executed. The brackets which follow main are used for this purpose. argc refers to the number of arguments passed, and argv[] is a pointer array which points to each argument which is passed to mainA simple example follows, which checks to see if a single argument is supplied on the command line when the program is invoked.

    #include <stdio.>h
    main( int argc, char *argv[] )
    {
       if( argc == 2 )
          printf("The argument supplied is %s\n", argv[1]);
       else if( argc > 2 )
          printf("Too many arguments supplied.\n");
       else
          printf("One argument expected.\n");
    }

Note that *argv[0] is the name of the program invoked, which means that *argv[1] is a pointer to the first argument supplied, and *argv[n] is the last argument. If no arguments are supplied, argc will be one. Thus for n arguments, argc will be equal to n + 1. The program is called by the command line:

    $myprog  argument1

More clearly, Suppose a program is compiled to an executable program myecho and that the program is executed with the following command.

    $myeprog aaa bbb ccc

When this command is executed, the command interpreter calls the main() function of the myprog program with 4 passed as the argc argument and an array of 4 strings as the argv argument.

    argv[0]         - 	"myprog"
    argv[1] 	- 	"aaa"
    argv[2] 	- 	"bbb"
    argv[3] 	- 	"ccc"

# Multidimensional Arrays:

The array we used in the last example was a one dimensional array. Arrays can have more than one dimension, these arrays-of-arrays are called multidimensional arrays. They are very similar to standard arrays with the exception that they have multiple sets of square brackets after the array identifier. A two dimensional array can be though of as a grid of rows and columns.

    #include <stdio.h>

    const int num_rows = 7;
    const int num_columns = 5;

    int
    main()
    {
      int box[num_rows][num_columns];
      int row, column;

      for(row = 0; row < num_rows; row++)
        for(column = 0; column < num_columns; column++)
          box[row][column] = column + (row * num_columns);

      for(row = 0; row < num_rows; row++)
        {
          for(column = 0; column < num_columns; column++)
            {
              printf("%4d", box[row][column]);
            }
          printf("\n");
        }
      return 0;
    }

This will produce following result:

       0   1   2   3   4
       5   6   7   8   9
      10  11  12  13  14
      15  16  17  18  19
      20  21  22  23  24
      25  26  27  28  29
      30  31  32  33  34

The above array has two dimensions and can be called a doubly subscripted array. GCC allows arrays of up to 29 dimensions although actually using an array of more than three dimensions is very rare.

Advertisement

Online Image Processing

Indian Baby Names