BesTutors - Tutor World

String - Array and String

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 05:56:00 +0000

Strings in C are represented by arrays of characters. The end of the string is marked with a special character, the null character, which is simply the character with the value 0.

Because C has no built-in facilities for manipulating entire arrays (copying them, comparing them, etc.), it also has very few built-in facilities for manipulating strings.

In fact, C's only truly built-in string-handling is that it allows us to use string constants (also called string literals) in our code.

Whenever we write a string, enclosed in double quotes, C automatically creates an array of characters for us, containing that string, terminated by the \0 character.

For example, we can declare and define an array of characters, and initialize it with a string constant:

char string[] = "Hello, world!";

Two ways to initilize string >

In this case, we can leave out the dimension of the array, since the compiler can compute it for us based on the size of the initializer.

This is the only case where the compiler sizes a string array for us, however; in other cases, it will be necessary that we decide how big the arrays we use to hold strings.

An example program showing the character data type array:

Out put of the program

In the above example, a character based array named word is declared, and each element of array is assigned a character.

The last element is filled with a zero value, to signify the end of the character string (in C, there is no string type, so character based arrays are used to hold strings).

A printf statement is then used to print out all elements of the array.

Function Definition - Function and Recursion

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 05:50:00 +0000

Functions are self contained program segments that carry out some specific well defined task.

In "C" , we include the header files like stdio, conio, string, etc.

These files contain number of library functions which are as follows:

printf( ), scanf( ), getchar( ), putchar( ), getche( ), gets( ), puts( ), strlen( ), getch( ), etc.

In C it is possible for the function to call themselves. we will see how it can be possible through Recursions.

A Function is a self-contained block of statement that perform a coherent task of some kind. Every C program must have a function. One of the function must be main().

Why should we use Function?

a) Using function it becomes easier to write programs and keep track of what they are doing

b) Length of the program can be reduced by using function.

c) Debugging is easier.

d) It facilitates top-down modular programming.

Classification of Function

C function can be classified into two categories:

1. Library function:

They are predefined in the standard library of C. We need to include the Library.

2. User-defined function:

User defined functions are need to be developed by the user at the time of program writing.

Function Declaration - Function and recursion

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 05:43:00 +0000

Before defining the function, it is desired to declare the function with its prototype.

In function prototype, the return value of function, type, and number of argument are specified.

Function declaration is written in following ways:

return data_type function_name (data_type argument 1, data_type argument 2 ................data_type argument n) { local variable declaration; executable statement 1; executable statement 2 .................................. ................................ executable statement n; return(expession); }

Note: An empty pair of parenthesis must follow the function name if the function definition does not include any arguments.

Example:

If it returns a float than command is:

float f1(float arg 1, int arg 2);

if it returns no value or return a character, then replace float by void or char respectively. If no arguments passed into a function than command is:

char fun1 ( );

An example program using a small add function:

Out put of the program

Function Call - Function and Recursion

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 05:36:00 +0000

Function can be called either by value or by reference .A function can be called by specifying its name followed by a list of arguments enclosed in parentheses and separated by commas.

From the above example the following line is used as a function call:

sum=add(a,b); /* function call */

Call by value: Call by value means directly pass value within the function.

An example program of call by value:

Out put of the program

Call by reference: Call by reference means sending the addresses of the argument to the called function.

In this method the addresses of actual arguments in the calling function are copied into formal arguments of the called function. (later discussed in pointer section)

The Return Statement

Information is returned from the function to the calling portion of the program via return statement.

General form of return statement:

return;

return(expression);

Storage Classes

There are two different ways to characterize variables:

1. By data type

2. By storage Class

Data type refers to the type of information while storage class refers to the life time of a variable and its scope within the program.

A variable in c can have any one of the four storage classes:

1. Automatic Variable:

It is created when the function is called and destroy when the function is exited. Hence the name is Automatic. By default a variable is declared Automatic.

2. External Variable:

It is also known as Global Variable. This variables can be accessed from any function that falls within their scope.

3. Static Variable:

A static variable may be either internal or external type , depending on the place of declaration.

Internal static variable extends up to the function in which they are defined and external static variable is declared outside of all function and is available to all the functions in the program.

4. Register Variable:

We can tell the compiler that a variable should be kept in one of the machine's registers, instead of keeping in the memory (where normal variables are stored ).

Since, a register access is much faster than a memory access and keeping the frequently accessed variables in the register will lead to faster execution of programs.

Recursion - Function and Recursion

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 05:32:00 +0000

Repetitive calling of the same function is called recursion. Recursions are those functions which call itself again and again. Recursive functions can easily become infinite loops.
An example program to find out the factorial of any number is the one of the best example of recursion:

Out put of the program

Introduction - pointers

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 05:27:00 +0000

Pointers are a fundamental part of C. If you cannot use pointers properly then you have basically lost all the power and flexibility that C allows. The secret of C is in its use of pointers.

C uses pointers a lot. Why?

It is the only way to express some computations.

It produces compact and efficient code.

It provides a very powerful tool.

C uses pointers explicitly with following:

1. Functions.

2. Arrays.

3. Structures. (discussed later)

Note: Pointers are perhaps the most difficult part of C to understand. C's implementation is slightly different from other languages.

What is a Pointer?

A pointer is a variable which can hold the address of a memory location rather than the value at the location.

Pointer Notation

The actual address of a variable is not known immediately. We can determine the address of the variable using address of operator(&).

We have already seen the use of address of operator in the scanf() function.

Another pointer operator available in C is "*" called "value of address" operator. It gives the value stored at a particular address. This operator is also known as indirection operator.

Pointer Declaration

To declare a pointer to a variable:

int *pointer;

Note: We must associate a pointer to a particular type: You can't assign the address of a short int to a long int,

Pointer expression - pointers

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 05:26:00 +0000

Like other variables pointer variable can also be used in expressions. Arithmetic and comparison operation can be performed on the pointers.

Pointer Arithmetic

Example:

Addition of a number to a pointer int i=4,*j,*

j=&i;

j=j+1;

j=j+9;

k=j+3;

Example:

Subtraction of number from a pointer int i=4,*j,*k;

j=&i;

j=j-2;

j=j-5;

k=j-6;

But the following operation are not allowed on pointers:

a) multiplication of pointer with a constant

b) addition of two pointer

c) division of pointer with a constant

Pointer Comparison

Pointer can be compared using relational operator. Expression such as- p1>p2 p1=p2 p1!=p2 are allowed.

Pointer & functions - Pointers

noreply@blogger.com (Jignesh Chheda) — Sun, 05 Oct 2008 04:52:00 +0000

Let us now examine the close relationship between pointers and C's other major parts. We will start with functions.

When C passes arguments to functions it passes them by value.

There are many cases when we may want to alter a passed argument in the function and receive the new value back once the function has finished.

C uses pointers explicitly to do this.

The best way to study this is to look at an example where we must be able to receive changed parameters. Let us try and write a function to swap variables around?

The usual function call:

swap (a, b) won't work.

Pointers provide the solution: Pass the address of the variables to the functions and access address of function.

Thus our function call in our program would look like this:

swap (&a, &b)

The Code to swap is fairly straightforward:

void swap(int *px, int *py)
{ int temp;
temp = *px;
/* contents of pointer */
*px = *py;
*py = temp;
}

Pointer & Array-Pointers

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:22:00 +0000

Pointers and arrays are very closely linked in C.

Hint: Think of array elements arranged in consecutive memory locations.

Consider the following:

int a[10], x;

int *pa;

pa = &a[0]; /* pa pointer to address of a[0] */

x = *pa;

/* x = contents of pa (a[0] in this case) */

Warning: There is no bound checking of arrays and pointers so you can easily go beyond array memory and overwrite other things.

C however is much more subtle in its link between arrays and pointers.

For example we can just type:

pa = a;

instead of

pa = &a[0]

and

a[i] can be written as *(a + i).

i.e. &a[i] =a + i.

We also express pointer addressing like this:

pa[i] =*(pa + i).

However pointers and arrays are different:

A pointer is a variable. We can do pa = a and pa++.

An Array is not a variable. a = pa and a++ ARE ILLEGAL

This stuff is very important. Make sure you understand it. We will see a lot more of this. We can now understand how arrays are passed to functions.

When an array is passed to a function what is actually passed is its initial element location in memory

So: strlen(s) strlen(&s[0])

This is why we declare the function:

int strlen(char s[]);

An equivalent declaration is:

int strlen(char *s);

since char s[] is equivalent to char *s.

strlen () is a standard library function that returns the length of a string.

Let's look at how we may write a function:

int strlength(char *s)

{

char *p = s;

while (*p != '\0');

p++;

return p-s;

}

Now let’s write a function to copy a string to another string. strcpy () is a standard library function that does this:

void strcopy (char *s, char *t)

{ while ( (*s++ = *t++) != `\0' );}

This uses pointers and assignment by value.

Note: Uses of Null statements with while.

Malloc Library Function

Function: Allocates main memory

Syntax: void*malloc(size_t size);

Prototype in: stdlib.h, alloc.h

Remarks: malloc allocates a block of size bytes from the C heap memory. It allows a program to allocate memory explicitly, as it is needed and in the exact amounts needed.

Calloc Library Function

Function: Allocates main memory

Syntax: void*calloc(size_t n size);

Prototype in: stdlib.h, alloc.h

Remarks: Calloc provides access to the C heap memory . Calloc allocates a block of size n items of x size. The block is cleared to 0.

Multi Dimensional Arrays & Pointer-Pointers

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:17:00 +0000

We should think of multidimensional arrays in a different way in C:

A 2D array is really a 1D array, each of whose elements is itself an array

Hence

a[n][m] notation.

Array elements are stored row by row.

When we pass a 2D array to a function we must specify the number of columns and the number of rows is irrelevant.

The reason for this is pointers again. C needs to know how many columns in order that it can jump from row to row in memory.

Considerint a[5][35] to be passed in a function:

We can do:

f(int a[][35]) {.....}

or even:

f(int (*a)[35]) {.....}

We need parenthesis (*a) since [] have a higher precedence than *

So:

int (*a)[35]; /*declares a pointer to an array of 35 int */

int *a[35]; /*declares an array of 35 pointers to int */

Now lets look at the (subtle) difference between pointers and arrays. Strings are a common application of this.

Consider:

char *name[10];

char Aname[10][20];

We can legally do name[3][4] and Aname[3][4] in C.

Arrays of Pointer-Pointers

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:16:00 +0000

We can have arrays of pointers since pointers are variables.

Example use: Sort lines of text of different length.

Note: Text can't be moved or compared in a single operation.

Arrays of Pointers are a data representation that will cope efficiently and conveniently with variable length text lines.

How can we do this: Store lines end-to-end in one big char array n will delimit lines.

Store pointers in a different array where each pointer points to 1st char of each new line.

Compare two lines using strcmp () standard library function.

If 2 lines are out of order swap pointer in pointer array (not text).

Pointer & functions -Pointers

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:13:00 +0000

When an array is passed to a function as an argument , only the address of the first element of the array is passed , but not the actual values of the array elements.

If x is an array, when we call sort(x), the address of x[0] is passed to the function sort().

The function uses this address for manipulating the array elements.

The address of a variable can be passed as an argument to a function in the normal fashion.

When address is passed to a function , the parameters receiving the address should be pointers.

The process of calling a function using pointer to pass the address of variable is known as call by reference.

The function which is called by reference can change the value of the variable used in the call.

Example:

main()

{

int x;

x=20;

change(&x);

printf("%d\n",x);

}

change( int *p)

{

*p=*p+10;

}

Explanation: When the function change() is called, the address of the variable x, not its value, is passed into the function change().

Inside change(), the value at which p points is incremented by 10 , and the changed value is then displayed in the main function.

Introduction-Structures

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:09:00 +0000

The C language allows us to create custom data types.

The structure is a custom data type which c combines different data types .

The structure is a custom data type which combine different data types to form a new user define data type.

Definition

A structure is a collection of variable reference under one name providing a convincible means of related information together.

Format: struct tag_name

{

data _type member1;

data_type member2;

-------------------

---------------------

};

here a keyboard struct declares a structes to hold the details of field of different data types.

Example:

struct addr

{

char name [30];

char city [15];

int pincode ;

};

Creating Structure variable

structure can be created in two ways:

1. declaration using tagname anywhere in the program.

Example:

struct book

{

char name [30];

char author [25];

float price;

};

struct book book1 book2

2. it is also allowed to combine structure declaration and variable declaration in one statement.

Example:

struct person

{

char *name;

int age;

char*address;

};

p1,p2,p3

while declaring structure variable along with their definition, the use of tag-name is optional.

Struct

{

char *name;

int age;

char * address;

}

p1,p2,p3

Image showing how the given value allocate in structure with the help of an example >

Giving values to member-Structures

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:07:00 +0000

The link between a member and a variable is established using member operator `.' to dot operator.

An example program to define a structure and assign value to members:

Out put of the program

Structure Initialization-Structures

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:05:00 +0000

a structure variable can be initialization as any other data type.

Main()
{
static struct
{
int weight;
float height;
}
}
student{560,080,75};

This assign the value 60 to student weight and 180.75 student height. there is a one to one correspondents between the members and their initializing values.

The following statements initialize two structures variables:

Main()
Struct st_decord
{
int weight;
float height;
}
static struct st_record student2={53, 170,60}
}

another method is to initlialize a structure variable outside the function.

Struct st_record/* No static word*/
{
int weight;
int height
}
student={60,50,75}
}
main()
{
static struct st_record student2={53,170,60}
}

Comparison of structure variables-Structures

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 16:02:00 +0000

Two variables of the same structure type can be compared the same way as ordinary variables.

operation meaning

person1=person2*assign perosn2 to person1

person1== person2*compare all name of person1 and person2 and return1

Arrays of structures-structure

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 15:57:00 +0000

The most common use of structures is in arrays of structures. To declare an array of structures, first the structure is defined then an array variable of that structure is declared.

E.g.: struct class student [100];

It defines an array called student which consists of 100 elements of structure named class.

Ans is stored inside the memory in the same way as a multidimensional array example program.

To implements on array of structures.

Arrays with in structures-Structures

noreply@blogger.com (Jignesh Chheda) — Sun, 29 Jun 2008 15:41:00 +0000

Single as multidimensional arrays of type int as float can be defined as structure members.

Example:

struct marks

{

int number;

float subject[3];

}

student [2];

Here the member subject contains three elements, subject[0], subject[1] and subject[2] there elements can be accessed using appropriate subscript.

For instance, the name student [1] student [2]; would refer to the marks obtained in the third subject by the secured student.

Structures with in structures-Structures

noreply@blogger.com (Jignesh Chheda) — Thu, 22 May 2008 13:29:00 +0000

Structures within a structure means nesting of structures.

Example:

struct salary
{
char name [20];
char department [10];
int basic-pay;
int dearness-allowance;
int huse_rent_allowance;
int city_allowance;
}
employee;

This structure defines name, department, basic pay and three kinds of allowances.

All the items related to allowance can be grouped together and declared under a sub-stricture. As shown below, strut salary

{
char name []2;
char department [10];
struct;
}
int dearness;
int house_rent;
int city;
[allowance;
}
employee's;

The salary structure contains a member named allowance which use is a structures with.

Three members. Now ; the member compared in the inner structure;, namely, ;dearness, house_rent and city can ;be left to as;

employee. ;allowance. Dearness
employee. Allowance. House_rent
employee allowance. city

The inner most member in a nested structure can be accessed by chaining all the concerned structure variables (from outermost to inner most) with the member using dot operator.

Passing structure to function-Structures

noreply@blogger.com (Jignesh Chheda) — Thu, 22 May 2008 13:22:00 +0000

There are three methods by which the values of structure can be transferred from one function to another:

1. The first method is to pass each member of the structure as an actual argument of the function call.

The actual argument is then treated independently like ordinary variables.

2. The second methods involve passing of a copy of the entire structure to the called function

Since the function is working on a copy of the entire structure to the called function,

changes are not reflected in the original structure (in the calling function).

It is necessary for the entire function to return the entire structure back to the calling function.

3. The third approach employs a concept called pointers to pass the structure as an argument . In this case,

the address location of the structure is passed to the called function.

The function can access indirectly the entire structure and work on it.

The general format of sending a copy of structure to the called function is:

function_name (structure_variable_name)

Introduction-Union

noreply@blogger.com (Jignesh Chheda) — Thu, 22 May 2008 13:08:00 +0000

Union are derived data types, the way structure are. Though, unions and structures look alike, and there is a fundamental difference.

While structure enables you to create a number of different variables stored in difference places in memory, unions enable you to treat the same space as a number of different variables

Union-Definition and Declaration

Unions, like structures, contain members whose individual data types may differ from one another.

However, the members within a union all share the some storage space within the computer's memory, whereas each member within a structure is assigned its own unique storage area.

Thus, unions are used to conserve memory.

They are useful for applications involving multiple members, where values need not be assigned to all of the members at any one time.

Within a union, the bookkeeping required to store members whose data types are different (having different memory requirements) is handled automatically to the compiler.

However, the user must keep track of what type of information is stored at any given time.

An attempt to access the wrong type of information will produce meaningless results. In general terms, the composition of a union may be defined as:

Union tag
{
Member 1;
Member 2;
…..
member n;
};

Where union is required keyword and the other terms have the same meaning as in a structure definition.

Individual union variables can then be declared as: storage-class union tag variable 1, variable 2, . . . , variable n;

Where storage-class is an optional storage class specified, union is a required keyword, tag is the name that appears in the union definition, and variable 1, variable 2, . . . , variable n are union.

The two declarations may be combined, just as we did with structures. Thus, we can write Storage-class union tag

{
Member 1;
Member 2;
. . . . .
member n;
}

The tag is optional in this type of declaration.

Notice that the union and structure declarations are external to the program functions, but the structure variable is defined locally within each function.

Accessing a union member-Union

noreply@blogger.com (Jignesh Chheda) — Thu, 22 May 2008 12:53:00 +0000

To access a union member, you can use the same syntax that you use for structure members.

Example:

code.m, code.x etc.

During execution, we should make sure that the value of accessing member is currently stored.

Initialization of Union variable-Union

noreply@blogger.com (Jignesh Chheda) — Thu, 22 May 2008 12:41:00 +0000

A union variable can be initialized , provided its storage class is either external or static.

Only one member of a union can be assigned a value at any one time.

The initialization value is assigned to the first member within the union.

An example program to demonstrate initialization of union variables:

Uses of Union-Union

noreply@blogger.com (Jignesh Chheda) — Thu, 22 May 2008 12:38:00 +0000

Union, like structure, contain members whose individual data type may differ to each other.

But the members that compose a union share the same storage area within the computer's memory, whereas each member within a structure is assigned its own unique storage area.

Thus, union are used to conserve memory.

1. Unions are useful for application involving multiple members, where value need not to be assigned to all of the members at any one time.

2. Unions are useful whenever there is a requirement to access the same memory location in more than one way. etc.

Linked list-Dynamic Data Structure

noreply@blogger.com (Jignesh Chheda) — Thu, 22 May 2008 12:28:00 +0000

Before talking about the different mechanism of data structure we will take a short view of DMA (Dynamic Memory Allocation).

DMA: C language requires the number of elements in an array to be specified at compile time.

But it is not practically possible with Array.

In array we allocate the memory first and then start using it.

This may result in failure of a program or wastage of memory space.

The concept of dynamic memory allocation can be used to eradicate this problem.

In this technique , the allocation of memory is done at run time.

C language provides four library function known as memory management function that can be used for allocating and freeing memory during program execution.

These are:

malloc: allocate memory and return a pointer to the first byte of allocated space.

Example:

ptr=(cast.type*)malloc(byte_size);

calloc: allocates the memory spaces, initialize them to zero and returns pointer to first byte.

Example:

ptr=(cast_type*)calloc(n.elem_size);

free: frees previously allocated space.

Example:

free(ptr);

realloc: modifies the size of previously assigned space

Example:

ptr=realloc(ptr,newsize);

We studied about Array there we can observe one major disadvantage of Array is ,if an array is not filled by value, then memory will be locked up.

To overcome this problem we use Linked lists and other data structure mechanism.

Linked List are a way to store data with structures so that the programmer can automatically create a new place to store data whenever necessary.

Specifically, the programmer writes a struct definition that contains variables holding information about something, and then has a pointer to a struct of its type.

Each of these individual struct in the list is known as a node. Think of it like a train. The programmer always stores the first node of the list.

This would be the engine of the train.

The pointer is the connector between cars of the train.

Every time the train add a car, it uses the connectors to add a new car.

This is like a programmer using the keyword new to create a pointer to a new struct

In memory it is often described as looking like this:

---------- ----------
- Data - >- Data ->
---------- - ----------
- Pointer- - - - Pointer-
---------- ----------