C - Useful Concepts

C - Programming HOME
C - Basic Introduction
C - Program Structure
C - Reserved Keywords
C - Basic Datatypes
C - Variable Types
C - Storage Classes
C - Using Constants
C - Operator Types
C - Control Statements
C - Input and Output
C - Pointing to Data
C - Using Functions
C - Play with Strings
C - Structured Datatypes
C - Working with Files
C - Bits Manipulation
C - Pre-Processors
C - Useful Concepts
C - Built-in Functions
C - Useful Resources
Computer Glossary
Who is Who
Copyright © 2014 by tutorialspoint
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.
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>. 

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 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 *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 free(void *mem address) - Free a block of memory.
void *malloc(size_t num bytes) - Allocate 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.
void *realloc(void *mem address, size_t newsize) - Reallocate (adjust size) a block of memory.
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"

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.

Advertisements


    6 Lectures 
     1.5 hours 

 Mr. Pradeep Kshetrapal

    41 Lectures 
     5 hours 

 AR Shankar

    11 Lectures 
     58 mins

 Musab Zayadneh

    59 Lectures 
     15.5 hours 

 Narendra P

    11 Lectures 
     1 hours 

 Sagar Mehta

    39 Lectures 
     4 hours 

 Vikas Yadav
 Print
 Add Notes
 Bookmark this page