first programme in C

#include
#include <conio.h>

void main()
{
clrscr();
printf("HI! am learning C - language");
printf("\n");
getch();
}

Common Binary Data Operations with C..

Common Binary Data Operations with C

Now that you know how to compile and link your programs, let's dive into the magic world of bitwise operations. At first these might seem really confusing, but you will notice that you have in fact seen all of them during Computer Engineering.

Shift Operations

It might seem a bit more cryptic than the first example, but don't be frightened. What you see is the usual stdio.h which is included at the beginning and then a function called getbinarystring. Skip it over and move on to the main function, which introduces two consecutive loops right after a block that handles command line processing.

The binary shift operator in C is a double-less-than or a double-greater-than character. Less-than means shifting to the left and greater-than the opposite. In effect, binary shifting is actually multiplying or dividing by powers of two. So, if you wish to divide a value by four, you shift the bits to the right by two:

value = value >> 2;

... Or if you want to multiply by 8:

value = value <<>

Of course, you need to know that overflows are not prohibited and you might send your MSB:s to bit heaven!

Bitwise AND

You can use two notations to perform bitwise and-operations:

result = op1 & op2;

.. or ..

result &= op;

which is equal to

result = result & op;

Experiment with the code in file and.c.

Bitwise OR

The notation of OR is similar to AND in C, but the operator character is a pipe character:

result = op1 | op2;

Again, there is a code snippet in file or.c that should clarify the usage of OR operator.

Bitwise XOR

Have a look at file xor.c and see that the XOR operation is nothing special, except for the operator character in C, a caret: ^.

Structures in C

Structure

You may recall the object oriented approach to programming. Forget data concealing, protection, member functions and inheritance and you end up with C structures.

No, seriously, C structures are a nifty way to avoid redundance in data structures. Consider the example in file structs.c. The source introduces two structures:

Plain structure definition:

struct cat {
int age;
char *name;
} mycat;

This is the way to introduce a single structure reference, in this case it is called mycat. You can reference this structure via the mycat-variable from anywhare within this source file.

Structure type definition:

typedef struct {
int age;
char *kind;
} alldogs;

In this case alldogs refers to a type definition, which can be used to declare variables later on. It works just like a normal variable declaration:

alldogs mydogs[3];

To access the variables within structures, there are two ways, depending on the type of variable which is used to refer to the structure data:

Immediate reference:

alldogs mydogs;
mydogs.age = 15;
mydogs.kind = "keeshond";

The simplest way to use structures is to reference them directly and you have access to the member variables with the '.'-operator. You can create arrays of structure variables, but using the pointer arithmetic method to access array elements should be avoided. There is a substantial amount of hidden magic behind memory allocation and data alignment, and the best way to avoid trouble is to not do anything exotic with structure arrays.

Pointer to a structure:

alldogs *mydogs;
/* allocate memory for the mydogs-structure before doing the following! Use
* malloc()!
*/
mydogs->age = 15;
mydogs->kind = "rottweiler";

The mydogs-variable is a pointer and we have to use the "arrow" style notation to reference the structure members. You could also use this kind of style: (* mydogs).age = 15;

Arrays in C

Arrays

Arrays in C are a very powerful way to access data, because they are contiguous memory sequences and they allow random access to their contents. What's more, array variables are actually pointers to the beginning of the contiguous memory block. There are two ways to access an array depicted in file arrays.c:

Indexed reference with brackets: a[cnt] = 'a' + cnt;

This is the common way to access an array, and it is by far the most intuitive way. The variable cnt simply denotes the index of an array element in array a.

Pointer arithmetics: *(a + cnt) = 'b' + cnt;

Because the arrays in C are always contiguous, it is possible to access their elements by incrementing the array pointer by the index value and referring to the element.

You can define an array with a constant size using the bracket notation: int a[15];. Some C compilers are also happy with the following notation: int *a = {1, 2, 3, 0};. Strings in C are char arrays and practically all compilers can deal with the following type of declaration: char *name = "Copernicus";, which creates a char array of length 11, last element being a NULL character. ALL STRINGS IN C MUST END IN A NULL CHARACTER!

You can use multi-dimensional arrays in C. Arrays are indexed in row-major style and you have to be careful about how your program walks through the indexes.

int a[20][4];

That code block defines an 20-row array of four-number arrays. Using pointer arithmetic, you can access row 3, column 2 like this:

int row = 3;
int col = 2;
int val = *(a + ((row * 4) + col));

In some programs the command line is processed by looking at the parameters defined in the main function. First parameter contains the number of arguments that have been passed to the program and as we take two values from the command line, it should be equal or higher than two. The second parameter seems a bit complicated, but it really isn't. As you should already know, one can access data arrays in C in many ways. The double asterisk ('**') tells you and the compiler that the variable in question must be a pointer to another pointer. Simple, huh? :) So, when it is later referred to with brackets or double brackets, the compiler knows that it is legal to do so.

Pointer

Pointers



A pointer is a variable that contains the address of another variable (either numeric or string, or a function) instead of a directly accessible value.

When declaring a pointer, you must include the type of the variable whose address this pointer will contain, so that the compiler knows how many bytes to read/write when it will access the value that this variable contains. To differentiate pointers from other variable types, a pointer is declared using an asterisk (*).

As an example, int *ptr declares a pointer to an integer. That is, ptr will hold the address of a variable of type integer. Since the compiler was told that the variable whose address ptr holds is an integer, it knows that it should read/write 4 bytes (the size of an integer is platform dependent, but it's usually 4 bytes.)

Knowing the length of the actual value this variable uses also allows you to move back and forth through a multi-byte value such as a string using the ++ and -- quantifiers:

char *mystr="My string";

printf("First character: %c\n",*mystr); //Alternatively, you can use *mystr++ to combine two lines in one
mystr++;
printf("Second character: %c\n",*mystr);

To initialize a pointer, you need to extract the address of a variable, using the & sign:

int *ptr=NULL; //It's a good habit to use the NULL macro to initialize a pointer right away
int someint;
ptr = &someint; //Now, ptr contains the address where someint lives in RAM, not its actual value

To access the value that the variable points to, you must dereference the pointer, that is, tell the compiler that you wish to go to the address that the pointer holds, and read/write the value that this memory cell holds. Here's an example:

someint = 16;
printf("Reading the value of someint directly: %d\n",someint);
printf("Reading the value of someint by dereferencing ptr: %d\n",*ptr);

Now, let's change the content of the variable by dereferencing ptr:

*ptr = 32; //Equivalent to someint=32;
printf("Reading the value of someint directly: %d\n",someint);
printf("Reading the value of someint by dereferenceing ptr: %d\n",*ptr);

The name of an array is actually the address of the first element:

int myarray[]={1,2,3};
int *arrptr;
arrptr = myarray; //You can also use &myarray[0];

printf("First element: %d\n",*arrptr);
printf("First element: %d\n",arrptr[0]);

A string is actually an array of characters that ends with a NUL character, ie. ASCII 0, is a pointer to the first character, and when a string is passed to a function, the function will work on the actual string since it receives the address of the array instead of a copy made when calling the function:

void myfunc(char arr[])
{
arr[0]='X';
}

int main(void)
{
char myarr[]="This is a string"; //could also use char *myarr="This is a string";
printf("Original string:%s\n",myarr);

myfunc(myarr);

printf("After myfunc: %s\n",myarr);
return 0;
}

Important: when using a char pointer to create a string, the string is read-only, ie. if you need to change the contents of the string, you should use char [] instead:

int main(void)
{
//BAD---------
char *myarr="This is a string";
//GPF because the string is immutable
*myarr='X';

//Good----------
char myarr[]="This is a string";
myarr[0]='X';
return 0;
}

Since a string created with the "char *" format is immutable, you could add the "const" prefix to get a compile-time error in case you changed the contents of this string:

//Without "const", the compiler may not say anything
const char *mystr="Before";

//no run-time crash, since compiler chocked on this
*mystr='X';

Note that it's OK to reuse the pointer to set it to a new string, though, since it's the memory space used to store the string itself that is immutable, not the pointer:

const char *mystr="Before";

mystr="After";
puts(mystr);

I read that GCC accepts the "-fwritable-strings" switch to allow a pointed string to be writable, but this is likely to be non-portable across compilers. A better alternative is to use malloc() and free() to allocate memory dynamically:

#define STR "This is a string"

void myfunc(char *arr)
{
//alternative: arr[0]='X';
*arr='X';
}

int main(void)
{
//Add 1 for terminating \0; calloc() sets string to \0, while malloc() doesn't
char *str = (char*) calloc(strlen(STR) + 1,sizeof(char));

strncpy(str,STR,strlen(STR));

printf("Original string:%s\n",str);
myfunc(str);
printf("After myfunc: %s\n",str);
free(str);
str = NULL; //Good practice

return 0;
}

why should we learn C?

You should learn C because:

* C is simple.
* There are only 32 keywords so C is very easy to master. Keywords are words that have special meaning in C language.
* C programs run faster than programs written in most other languages.
* C enables easy communication with computer hardware making it easy to write system programs such as compilers and interpreters.



Getting equipped to write C programs

The tools required for C programming are simple. All you need are:

1. A text editor: A text editor allows you to type in, modify, and save your program. Notepad in Windows, Edit in DOS, and vi and Emacs in Unix/Linux are some popular text editors.

2. A C compiler: A compiler is a program that converts the high-level language (HLL) program (referred to as source code) into machine language (object code). Borland C, GCC, and Microsoft C are some of the popular compilers.

Where C is useful?

C’s ability to communicate directly with hardware makes it a powerful choice for system programmers. In fact, popular operating systems such as Unix and Linux are written entirely in C. Additionally, even compilers and interpreters for other languages such as FORTRAN, Pascal, and BASIC are written in C. However, C’s scope is not just limited to developing system programs. It is also used to develop any kind of application, including complex business ones. The following is a partial list of areas where C language is used:

• Embedded Systems

• Systems Programming

• Artificial Intelligence

• Industrial Automation

• Computer Graphics

• Space Research

• Image Processing

• Game Programming

Introduction to turbo C

The C (Beginners All Purpose Symbolic Instruction Code) language has been around since early days of computing and its principles are familiar to most of the people with programming experience. C language was used by programmers more than in the history of computing. C was also the most popular language because of its simplicity in understanding the code. However, the advent of the windows environment provided a new challenge to C programmers.

Turbo C, as a language, is a powerful development environment. A wide range of application ,ranging from simple stand-done application to powerful internet based applications ,can be developed in turbo C.