Programming & DS

Chapter 1:C program – A System View

July 9, 2016 by arjun Leave a Comment

I assume that all of you would have got the setup of running a $C$ program ready. Some clarifications on my previous instructions:

$T u r b o$ $C$ is a 16 bit compiler made for $M S - D O S$ . Some school student may say that it’s easy to start with but I say it is difficult to program in $T u r b o$ $C$ . Now, we are living in the world of 64-bit compilers and so we should learn to program for that.
Why linux? Absolutely no need to use linux for learning C. But I would like to give an overview of the whole computer system (in this chapter itself), and it would be based on linux. As a computer science student if you don’t know how to use linux, you are like a purse without money. So, start using at least now.
Why AWS? It is not needed if you are having some linux distribution on your machine. But otherwise it is a very good idea to use AWS. It gives a shell on a linux system and you have full control of the OS. And it is free also (for normal usage). Moreover, AWS is used by many companies, and this would be a simple exercise to get used to it.

Now, if you are having a $g c c$ or $i c c$ compiler on windows, its very much okay. But just one clarification: We won’t be using the word “Turbo C” further in any of the discussions.

What a $C$ program does?

First of all why are we using $C$ language? We can start from there:

Digital Circuits

We all know that the most important thing inside our CPU is the processor. It is made up of digital components like flip-flops and those who have studied digital circuits would understand that the digital circuits produce output from the input, when supplied with power and a clock. The speed at which the output is produced is determined by the clock speed of the CPU, because the clock determines the speed of transfer of bits between different units (and that’s why a 3 GHz processor is faster than a 1 GHz processor). But this will be effective only if the processor has the input data available. (Most times there is delay for the CPU to get the input data and that’s why the actual running time of a process on a 1GHz processor is not 3 $\times$ , compared to the same process running on a 3GHz processor.)

Computer Organization

The reason for the above problem is that data is given to processor from memory and the time to take a data from memory to processor is high, say 100 $\times$ , the speed at which the processor works. So, we use many techniques like buffering, caching etc. to minimize this effect.

Okay, so now our aim is to give data to the $C P U$ and it has these circuits called Functional Units to perform the specified tasks. Each functional unit does some job like addition, multiplication etc. and they give the result when provided with the input(s). But these input and output are in binary, as all these units are digital. That is, the input to $C P U$ will be a series of $0$ ‘s and $1$ ‘s and the output will also be a series of $0$ ‘s and $1$ ‘s. So, what happens to the CPU when we give some string of $0$ ‘s and $1$ ‘s? Not all such strings will produce a valid output and this is entirely dependent on the processor. The processor manufacturer clearly specifies what’s the meaning of each combination $0$ ‘s and $1$ ‘s and that is called the language of the processor which is entirely determined by its architecture.

Computer Architecture

Most of our systems are $\times 86$ architecture and it has its own Instruction set. So, lets take an example string of $0$ ‘s and $1$ ‘s in it:

00000101 00000000 00000000 00000000 00000001

1	00000101 00000000 00000000 00000000 00000001

This set of strings will add $1$ to the content of $E A X$ register (a register is a very fast memory inside the processor for holding data, and $E A X$ is one among them in $x 86$ architecture) which is a $32$ -bit register . The first byte is $00000101$ which is given to the Instruction decode unit inside the processor which tells the $C P U$ that it must add the next $32$ bits to the contents of $E A X$ register. Now, the next $32$ -bits will be given to the $A D D$ unit which will add it to the contents of $E A X$ register. In our example, the $32$ bits represents just $1$ and so the addition results in an increment of $1$ .

[Small question: Instead of ADD, if we use INC instruction, it results in better performance. How?]

So, this is how the CPU works- everything is in binary. We can get the meaning of each binary string from the Intel Instruction manual

To make things slightly easier they encode the bit-strings as $H E X$ codes. So, the above bit string will become

05 00 00 00 01

1	05 00 00 00 01

Even then, it is difficult to write a program like this. Because human mind is not good at remembering numbers. So, then came Assembly language. Here, we use mnemonics to represent each operation. For example $A D D$ is the mnemonic to do addition, $S U B$ is the mnemonic to do subtraction etc. So, instead of the above binary string, now we can write

ADD EAX, 01

1	ADD EAX, 01

and the assembler will translate it into

05 00 00 00 01

1	05 00 00 00 01

Ahh! Much easier world for a programmer. But imagine writing an assembly program to print the factorial of n. How much time is needed to write it using these kinds of mnemonics, for each operation in the algorithm? Wouldn’t it be better if we say the algorithm and then that is translated to binary string by $< s o m e o n e >$ ? Yes, that’s where $C$ language comes. We can straight away represent most algorithms in $C$ , and the $C$ compiler will translate it into the binary string in the same way an assembler would do for assembly language.

So, lets write the $C$ code for the above addition.

int a;
a = a + 1;

1 2	int a; a = a + 1;

This will do the same job as

ADD EAX, 01

1	ADD EAX, 01

assuming $a$ is the value we had in $E A X$ .

Now, to start executing a program we need an entry point to the code. This is often named as $m a i n$ . The program starts executing from the first instruction inside $m a i n$ . So, to make our $C$ code complete, we do the following

 #include<stdio.h>
 int main () {
   int a;
   a = a + 1;
   printf(" a = %d\n", a);
 }

#include<stdio.h>

int main () {

int a;

a = a + 1;

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

}

For now lets assume that the $p r i n t f$ statement prints the value of $a$ . But, $C$ language has a restriction that before any variable is used, its type must be specified. So, before using $p r i n t f$ , we must tell its type. Its type is written in a file called $‘ ‘ s t d i o . h "$ so we can include that file (which will make all the contents of that file as part of our file) or we can just give the correct type of $p r i n t f$ as

int printf(const char *, ...);

1	int printf(const char *, ...);

Directly writing the declaration of $p r i n t f$ is not recommended and I just gave it to show the functionality of $# i n c l u d e < s t d i o . h >$ . Many people still think that code of printing is inside $‘ ‘ s t d i o . h "$ and that’s completely wrong. Code of $p r i n t f$ is part of standard $C$ library which is available as $l i b c$ (there must be a file called $l i b c . s o$ in linux and $p r i n t f$ code is inside that). The usage of $l i b c . s o$ file is that the same code can be used by many programs (all linking to the same library code) so that reduces the main memory required to run the programs.

So, this usage of sharing $l i b c$ saves the total memory required when these 4 programs are concurrently executing. (If you want to see how many processes are executing at this moment on your system, just type $t o p$ in a shell).
By default $g c c$ will link to any function inside $l i b c$ , if we call them in our program. But if we use any other library function, we have to explicitly tell $g c c$ to link to that library. For example, to use $s i n (x)$ in a code we have to link to math library ( $l i b m$ ) as follows:

gcc prog.c -o prog -lm
(l is written instead of lib, so libm becomes lm, libc becomes lc ...)

1 2	gcc prog.c -o prog -lm (l is written instead of lib, so libm becomes lm, libc becomes lc ...)

Once we compile the code $g c c$ will be producing the output in a file called $p r o g$ which is given with the $- o$ option. If we don’t give any $- o$ option, output by default goes to a file called $a . o u t$ . This will be in binary format and we cannot see it as text. This binary contains the bitstrings to be given to the processor as we discussed in the beginning. But some codes like that of $p r i n t f$ is not inside this binary and is at a common location, which is called by our binary. Can we make copy the $p r i n t f$ code and other library functions to be inside our binary? Yes, we can with the following command:

gcc prog.c -o progS -lm -static
(progS is just a different name)

1 2	gcc prog.c -o progS -lm -static (progS is just a different name)

Now, just see the size difference of the two binaries using $l s$ command

ls -l prog

1	ls -l prog

Now, to get the output by running the executable, we have to do

./prog 
(./ just tells that prog is in the current directory)

1 2	./prog (./ just tells that prog is in the current directory)

Once the binary is produced by the compiler, before we get the output, there are many stages:

Loading: Copying the content of the binary file to memory
Linking: Fixing the calls in the binary which are to shared libraries as in the case of $p r i n t f$
Process starts: Now the OS makes a process for our program (it gets a $p i d$ ) and it’ll be in $r e a d y$ state.
When the turn comes, our process will get executed (it can be stopped in between to give other processes their turn)
When our process is being executed, the binary strings inside it (which are instructions to the processor) are send one by one to the processor, which executes them
Memory Management: For all the memory required by the process, the Memory Management Unit ( $M M U$ ) ensures that the memory addresses used inside the object code (which are virtual addresses) are properly mapped to physical memory locations on the $R A M$

So, even after the compilation (which of course includes its own phases) there are so many phases before we get the output of a $C$ program.

We’ll stop this chapter after mentioning about how we get segmentation fault in our programs.

Segmentation Fault

When a process is made by the $O S$ , it allots some memory to it. This can be increased during its execution, upon request to the $O S$ , and can go up to a limit set by the $O S$ . So, when this process goes to execution state, it can only access the memory allotted to it. (This is done by giving a $p a g e t a b l e$ to each process and all memory accesses are done through it). Whenever a process tries to access a memory which is not allotted to it, $s e g m e n t a t i o n f a u l t$ occurs. Segmentation fault also occurs, if a process tries to write something to a read only memory area. For example, a program memory consists of many parts called segments and there are code segment, data segment and stack segment. Of these, the data segment is again divided into Read Only ( $R O$ ) data segment and Read Write ( $R W$ ) data segment. Among these segments only the $R W$ data segment and stack segment are allowed to be modified by a process. (Some systems allow code segment also to be writable and can be used for writing self modifiable code) If a process tries to modify any other segment, then also segmentation fault happens. (Segmentation fault also happens due to some special hardware instructions, but we can ignore them as this won’t happen for general programs compiled in a normal way.)

In this first chapter we have skimmed across compilers, memory management, process management, computer organization and computer architecture, which covers the basics of a Computer System. So, in order to run a very simple program itself we require all these. If you understand the basic functioning of these topics, that will be enough for an exam like $G A T E$ . From next chapter onward, we’ll go inside $C$ .

5,809 total views, 8 views today

Why I should not use Turbo C?

May 22, 2016 by arjun 1 Comment

For a beginner he will be learning wrong concepts like conio.h and clrscr must be used in all c programs
Return type of main is int in all standard C compilers but Turbo C forces void
Difficulty in coding- Turbo C forces all declarations before any function call while Standard C compilers allows declaration anywhere.
int a [10][1000] is not possible in Turbo C while modern compilers allow at least 100 times this size.
Far, huge pointers- another not needed concept in Turbo C
C is for system programming, Turbo C won’t teach you any system as DOS is no longer in use
“I code in Turbo C” is enough to get the exit ticket from any good company interview
I’m lazy- I don’t want to write conio.h, clrscr and getch for every C code when it is absolutely not necessary to type them in any standard C compiler
A C compiler is supposed to translate a C code to machine code. But the code generated by Turbo C is not meant for any current machine (architecture). It is meant only for DOS (just because DOS emulator is there it works in Windows, but not useful for making any application outside DOS). Use the appropriate compiler for your machine and choose others when you can’t find one. In most architecture you can get gcc which is the most widely used compiler and is also opensource.

Best option for System Programming

on 64 bit machines

Any other flavor of Linux would also do.

Ubuntu 16.04

Other architectures

Ubuntu 16.04

How to make a bootable Ubuntu disk

For anymore doubt in installation you can ask below. It hardly takes 20-30 minutes to dual boot your laptop with both windows and Ubuntu.

For those who don’t want to use Ubuntu (I don’t know why?) and want to use only Windows

Codeblocks with gcc for Windows

A short Tutorial for migrating to gcc on Windows

4,051 total views, 5 views today

C Book Chapter 3: Pointers

April 19, 2016 by arjun 2 Comments

Pointer as the word implies just points. It is a datatype in C which is used to hold memory address. Pointers may point to any datatype in C and based on the data type pointer arithmetic is done.

1 * Operator
- 1.1 Example
2 Pointer Arithmetic
3 Does a pointer have memory?
- 3.1 Example
4 Assigning values to pointers
- 4.1 Example
5 Problems with pointers
6 Exercise Questions

* Operator

A pointer is declared using * as follows:

int* p; //p is a pointer to int. int *p is also syntactically correct but * here is always taken with int as int* and p is the name for the variable. Many take this as *p which is not correct
char* y; //y is a pointer to char

1 2	int* p; //p is a pointer to int. int p is also syntactically correct but here is always taken with int as int* and p is the name for the variable. Many take this as p which is not correct char y; //y is a pointer to char

Actually pointer operation is very simple as there are just one operator for using pointer which is the dereferencing operator *.

*p -> gives the content of the location in p.

1	*p -> gives the content of the location in p.

What the content is, depends on the type of p. If p is an integer pointer, *p will return 4 bytes from the location contained in p. If p is a char pointer *p will return 1 byte from the location in p.

Example

int *p, a;
scanf("%d",&a); //memory address of a is passed to scanf and it stores the keyboard entered value in that location
p = &a; //Memory address of a is stored in p
printf("*p = %d", *p); //Content of p is printed by printf. Since %d is used, 4 bytes (assuming sizeof int is 4) from the memory location given by p is converted to integer and printed.

int *p, a;

scanf("%d",&a); //memory address of a is passed to scanf and it stores the keyboard entered value in that location

p = &a; //Memory address of a is stored in p

printf("*p = %d", *p); //Content of p is printed by printf. Since %d is used, 4 bytes (assuming sizeof int is 4) from the memory location given by p is converted to integer and printed.

The below code also does the same job but in a slightly different manner.

int *p, a;
p = &a;
scanf("%d",p);
printf("a = %d *p = %d", a, *p);

int *p, a;

p = &a;

scanf("%d",p);

printf("a = %d *p = %d", a, *p);

Pointer Arithmetic

Why do we do pointer arithmetic? It is to access the next or previous elements in an array of elements. For that reason pointer arithmetic is restricted to just addition and subtraction. And though pointers can be represented using integer values, as they hold memory addresses, pointer arithmetic is different from integer arithmetic. Pointer arithmetic works as follows:

//Assume p and q are pointers
 
p+1 //p is incremented to the next address for holding the data type for p. i.e; if p is an int pointer p+2 will add 8 to the content of p (assuming sizeof (int) is 4)
 
p-1 //p is decremented to the previous address for holding the data type of p
 
p-q //If p and q are pointers p-q will work as above and thus will
    //return the no. of objects of type of p between the memory addressess of p and q (p and q must be of same data type or else it is compilation error)
 
p+q //Not allowed and throws compilation error

//Assume p and q are pointers

p+1 //p is incremented to the next address for holding the data type for p. i.e; if p is an int pointer p+2 will add 8 to the content of p (assuming sizeof (int) is 4)

p-1 //p is decremented to the previous address for holding the data type of p

p-q //If p and q are pointers p-q will work as above and thus will

//return the no. of objects of type of p between the memory addressess of p and q (p and q must be of same data type or else it is compilation error)

p+q //Not allowed and throws compilation error

There are no multiplication or division operators in pointer arithmetic as they have no meaning.

Does a pointer have memory?

Yes, pointer is a data type and so has a memory for it. On a 32 bit system, pointer requires 4 bytes (32 bits) of memory while on a 64 bit system it requires 8 bytes. And it is the same for pointer to any data type. Since pointer has a memory, we can have a pointer to pointer as well and this can be extended to any level.

Example

 #include <stdio.h>
 int main() 
 {
   int a; 
   int* p;
   p = &a;
   int** q; //q is a pointer to a pointer to int
   q = &p;
   printf("a = %d, *p =%d, **q = %d\n", a, *p, **q);
 }

#include <stdio.h>

int main()

{

int a;

int* p;

p = &a;

int** q; //q is a pointer to a pointer to int

q = &p;

printf("a = %d, *p =%d, **q = %d\n", a, *p, **q);

}

Assigning values to pointers

Since pointers should hold valid memory address (OS allocates certain memory region for a process and it should use only that region and should not try to access other memory region), we should not assign random values to a pointer variable. Assigning some values to a pointer is allowed, but if that value is not in the memory address for the process, dereferencing that pointer using * operator will cause segmentation fault.

One way of assigning value to a pointer variable is by using & operator on an already defined variable. Thus, the pointer variable will now be holding the address of that variable. The other way is to use malloc function which returns an array of dynamic memory created on the heap. This method is usually used to create dynamic arrays.

Example

#include <stdio.h>
#include <stdlib.h> //contains the declaration for malloc
int main() 
{
  int a; 
  int* p = &a;
  *p = 6;
  p = malloc(10 * sizeof(int));
  *(p+5) = 7;
  printf("a = %d, *(p+5) = %d, p[5] = %d\n", a, *(p+5), p[5]);
}

#include <stdio.h>

#include <stdlib.h> //contains the declaration for malloc

int main()

{

int a;

int* p = &a;

*p = 6;

p = malloc(10 * sizeof(int));

*(p+5) = 7;

printf("a = %d, *(p+5) = %d, p[5] = %d\n", a, *(p+5), p[5]);

}

Problems with pointers

Pointers are very powerful but with power comes problems. Since, pointer allows direct access to memory address, if programmer is not careful, pointer usage can cause segmentation faults. The other problem with pointer is that pointer dereferencing is difficult to debug especially when there are more than two levels of indirection (pointer to pointers).

Exercise Questions

	1
	2
	4
	Compile Error
→	p is typecasted to char pointer and then dereferenced. So, returned type will be char and sizeof(char) is 1.

Yes

→

On a little endian machine the lower address will contain the least significant byte. Suppose a is stored at address 1000 and contains 1, then character at 1000 will be 1, if the machine is little endian.

Garbage value

Compile error

Segmentation fault

→

Assigning int values to pointer variable is possible. Only when we dereference the variable using *, we get a segmentation fault.

Garbage value

Compile error

Segmentation fault

→

Here, p is having address of a and the same is copied to pp. So, *pp will give 1 which is contained in a, but **p will use 1 as an address and tries to access the memory location 1, giving segmentation fault.

8. Assuming a little endian machine, what will be the output of the following program?

#include<stdio.h>
 
fun(int a)
{
  char *arr[] = {"0000", "0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"};
  unsigned char* p = (unsigned char*) &a ;
  p+=3;
  int i;
  for(i = 0; i < sizeof a; i++)
  {
    int d = (*p)>>4; 
    printf("%s", arr[d]);
    d = (*p) & 0xf;
    printf("%s ", arr[d]);
    p--;
  }
}
 
int main()
{
 int a;
 scanf("%d", &a);
 fun(a);
}

#include<stdio.h>

fun(int a)

{

char *arr[] = {"0000", "0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"};

unsigned char* p = (unsigned char*) &a ;

p+=3;

int i;

for(i = 0; i < sizeof a; i++)

{

int d = (*p)>>4;

printf("%s", arr[d]);

d = (*p) & 0xf;

printf("%s ", arr[d]);

p--;

}

int main()

{

int a;

scanf("%d", &a);

fun(a);

}

Print the binary of the input number

Compile error

Runtime error

Compiler dependent output

→

The code is printing the binary equivalent of the input number. Suppose a is stored starting from address 1000. Since, we assume a little endian machine, the LSB of a will be stored at address 1000 and MSB will be stored at address 1003. So, we make a char pointer to 1003 and take out the MSB. Then using shift operator we get the most significant 4 bits from it and then the least significant 4 bits. We repeat the same for the other three bytes of a.

13,807 total views, 6 views today

C Book Chapter 2: Data Types and Operators in C

April 19, 2016 by arjun Leave a Comment

$\text{C}$ is a just a language specification and $\text{C}$ compilers (which translates $\text{C}$ code to machine code) are made by different organizations/ individuals. So, in order to make a $\text{C}$ program work across multiple compilers, $\text{C}$ standard is important.

A little about C standards

Till $\text{ANSI}$ standard which is almost the same as $\text{C90}$ (also called $\text{C89}/ \text{C90}$) was published, the standard specified in $\text{K&R}$ book was used as a reference for C standard. Each new standard aimed at easing the programming difficulty as well as making use of the new hardware features. We’ll be following as much of $\text{C11}$ standard as possible as it adds some significant changes to $\text{C}$ language.

Data types

Data types are used to represent data and data comes from real world. In real world we have the following data types

Integer
Character
Real Numbers

All other data types can be formed from these basic types (for example, a string is just a sequence of characters). So, in $\text{C}$ language we have only these basic types but they are supported in various data sizes as follows

short int
int
long int
long long int
char
float
double
long double

Now, each of these type is supported in unsigned version also. In signed version, one bit is used to identify if the number is positive or negative. So, for a $32$ bit signed integer, it can represent only up to $2^{31} – 1$, while a $32$ bit unsigned integer can represent up to $2^{32} – 1$. A boolean data type is also present in C standard which can be used to hold a bit. This data type can be used using the keyword $\text{bool}$. If we use an $\text{int}$ (or $\text{char}$), to get a boolean value, we need to logical $\text{AND}$ (&) it with $1$. With $\text{bool}$, this conversion is not necessary as the byte representing the boolean will always have the most significant $7$ bits as $0$.

So, let’s see what these data types mean to computer. As we have seen in the previous chapter, all data must be converted into a bit stream before being given to the processor. So, even though we use alphabets and digits while writing programs, they are converted to bits, stored in the memory and then given to the processor. How many bits a data type can have is defined by the size of the data type. In $\text{C}$ language, the operator $sizeof$ gives the number of bytes (i.e., $8$ $*$ number of bits) a data type takes. Since, memory accesses are restricted to multiple of bytes ($\text{RAM}$ doesn’t allow to access data at a granularity lower than 8 bits at a time due to practical reasons) $sizeof$ always return at least $1$ for any data type. (A $\text{bool}$ also take a byte of storage as that is the smallest accessible unit in a memory, though it actually requires single bit of storage)
Now, let us see the size of various data types in $\text{C}$. Since, the data types are directly given to the processor, the size of data types depends on the processor architecture. So, $\text{C}$ standard tells the minimum required size specification, and have let the compiler designers choose the size as per their processor architecture- $\text{C}$ compilers are used in $8$ bit embedded processors to $64$ bit desktop processors. So, this size variation does make sense.

Data Type	Min.Size
char 1	1
short int 2	2
int 2	2
long int 4	4
long long int 8	8
float 4	4
double 8	8
long double	10

The size of $\text{char}$ is $1$ byte as it was sufficient for $\text{ASCII}$ encoding. But for extended $\text{ASCII}$ character support, $wchar$_$t$ which supports up to $16$ bits is defined in $C11$ standard. It also defines $char16\_t$ or $char32\_t$ in “uchar.h” header file, thus supporting Unicode characters which requires up to $21$ bits. So, in today’s world, a $\text{char}$ and an $\text{int}$ take the same size and, the integer variable ($char32$_$t$ of $4$ bytes) is used to store Unicode characters and the data type $\text{char}$ is used mainly to refer to a byte of data than an actual character.

Constants and variables

We have seen the data types, but to use them in a program we need to have a variable. A $\text{variable}$ is a named entity to represent a specific data type. The type of a variable is fixed during the program run, but its value can be changed, and hence the name variable. (In an object oriented language like $\text{CPP}$, a class can be taken as a data type and its instance become a variable). To assign a value to a variable we use $constants$. The following are the example usage of variables and constants.

int a; // 'a' is an int variable
a = 5; // 5 is an int constant

1 2	int a; // 'a' is an int variable a = 5; // 5 is an int constant

Constant Types

In $\text{C}$ language we have the following constants

Integer constant
- Decimal constant
- Octal constant
- Hexadecimal constant
Floating constant
Character constant
Enumeration constant

Integer Constant

C standard supports decimal, octal and hexa-decimal constants being used to assign integer values. Their example usage is as shown below.

#include <stdio.h>
 int main()
 {
    enum month{jan = 1, feb, mar, apr, may, jun, july, aug, sep, oct, nov, dec};//jan is having int value 1, feb value 2 and so on 
    int a,b,c; 
    a = 10; //10 is a decimal constant
    b = 0xa; // a is a hexadecimal constant
    c = 012; //12 is an octal constant
    enum month d = oct; //oct is an enumeration constant
    printf("a =%d, b = %d, c =%d, d =%d ",a,b,c,d);
    return 0;
 }

#include <stdio.h>

int main()

{

enum month{jan = 1, feb, mar, apr, may, jun, july, aug, sep, oct, nov, dec};//jan is having int value 1, feb value 2 and so on

int a,b,c;

a = 10; //10 is a decimal constant

b = 0xa; // a is a hexadecimal constant

c = 012; //12 is an octal constant

enum month d = oct; //oct is an enumeration constant

printf("a =%d, b = %d, c =%d, d =%d ",a,b,c,d);

return 0;

}

We can use an $\text{int}$ instead of $\text{enum}$ as both takes same amount of memory. But the use of $\text{enum}$ ensures that a variable can hold only a particular set of integer values rather than the whole range of integers. Thus it leads to less program errors and makes the code more readable by providing a set of defined constants. Here, $a$ is having the decimal value of $10$. So, in memory $a$ will be like

000...1010

1	000...1010

Similarly, $b$ will be in memory like

000...1010

1	000...1010

and $c$ and $d$ will also be like

000...1010

1	000...1010

i.e.; all $a$, $b$, $c$ and $d$ are having same integer values given using different constants. The memory to be allotted to an integer constant is determined by its value, minimum being the $sizeof(int)$. For example, $40$ is allotted the $sizeof(int)$ while 0xfffffffff is allotted $sizeof(long)$ as it won’t fit in $sizeof(int)$ bytes (assuming $sizeof(int)$ is $4$ and $sizeof(long)$ is $8$).

Floating Constant

To understand clearly floating point conversion, let us do a simple example. It is very clear in decimal number system, a real number can be represented in several ways. $23.75$ for instance is the same as

$2375 * 10^-2$
$0.2375 * 10^2$
$2.375*10^1$

Of these, the third manner, where the decimal point is placed after the first non-zero number is called the ‘normalized’ notation. If we were to develop a representation for a real number in decimal system, it should allow to represent the sign of the number along with the following details. For example, for the above real number, $2.375$, is known as the significant, $10$ is the base of the decimal number system, and $1$ is the exponent (can also be negative). Please follow Section 4.1 on number representation for a better understanding.

The representation of a floating point number is implementation specific. $\text{C11}$ do specify $\text{IEC}$ $60559$ format for floating point representation but its not mandatory that all implementations must support them. But most current implementations do support them and hence it’s good to have a look at them. $\text{IEEE}$ format is a good look as $\text{IEEE}$ $754$ is identical to $\text{IEC}$ $60559$

Constant values can be assigned to float or double variables in various ways as shown below. If a constant cannot be exactly representable in the float or double variable the implementation is recommended to show a warning as per C standard. But this is just a recommendation and not a strict requirement.

#include <stdio.h>
 int main()
 {
    float a = 10.2;
    float b = 2.3f;
    double c = 3.4l;
    double d = 1.2e-3;
    printf("a =.2f, b =%5.2f, c =%05.2lf, d =%len",a,b,c,d); //Just diff format specifiers
    //%.2f means 2 digits after decimal point will be printed 
    //%5.2f means the output will have a total of minimum 5 places including 2 decimal digits and a point. 
    //If lesser digits are there, then the remaining space is filled with white space.
    //%05.2f is same as&nbsp;%5.2f except that the remaining space, if any, are filled with 0s than white space

    return 0;
 }

#include <stdio.h>

int main()

{

float a = 10.2;

float b = 2.3f;

double c = 3.4l;

double d = 1.2e-3;

printf("a =.2f, b =%5.2f, c =%05.2lf, d =%len",a,b,c,d); //Just diff format specifiers

//%.2f means 2 digits after decimal point will be printed

//%5.2f means the output will have a total of minimum 5 places including 2 decimal digits and a point.

//If lesser digits are there, then the remaining space is filled with white space.

//%05.2f is same as %5.2f except that the remaining space, if any, are filled with 0s than white space

return 0;

}

Character Constant

Characters can be assigned value either by using a character in single quotes or by giving the integer value from the character code. And this int value can be given using hex or octal representation as well, as shown below. Escape sequences are applicable to character constants like $’\n’$, $’\t’$ etc. Character code values can also be used in place of a char by using their octal or hexa-decimal representation. Octal values are given by a preceding ‘\’ where the next three octal digits are converted to the corresponding character ($3$ octal digits suffice to get upto $256$). Hexa-decimal codes are given by a preceding ‘\x’ where the next two hexa-decimal digits are converted to the corresponding character ($2$ hexa-decimal digits suffice to get upto $256$).

#include <stdio.h>
 int main()
 {
    char a, b, c, d, e;
    char abc[] = "I \107OT \x49T"; 
    a = 'a';
    b = '\0';
    c = 0;
    d = '\x41'; //41 is a hexa decimal value whose corresponding ASCII char is assigned to d
    e = '\101'; //101 is an octal value whose corresponding ASCII char is assigned to e 
    printf("a =%d, b =%d, c =%d, d =%c e =%c abc = %s\n",a,b,c,d,e,abc);
    return 0;
 }

#include <stdio.h>

int main()

{

char a, b, c, d, e;

char abc[] = "I \107OT \x49T";

a = 'a';

b = '\0';

c = 0;

d = '\x41'; //41 is a hexa decimal value whose corresponding ASCII char is assigned to d

e = '\101'; //101 is an octal value whose corresponding ASCII char is assigned to e

printf("a =%d, b =%d, c =%d, d =%c e =%c abc = %s\n",a,b,c,d,e,abc);

return 0;

}

Here, $a$ is having the $ASCII$ value of $’a’$ which is $97$. So, in memory $a$ will be like

01100001

01100001

Similarly, $b$ and $c$ will be in memory like

00000000 //ASCII value of '\0' is 0

1	00000000 //ASCII value of '\0' is 0

and $d$ and $e$ will be like

01000001

01000001

Enumeration Constant

Enumeration constants are assigned integer values starting from a given initial value which by default is 00. An example is shown below:

enum player{ Dhoni = 1, Kohli, Yuvraj, Aswin = 5, Jadeja, Mishra = 10}

1	enum player{ Dhoni = 1, Kohli, Yuvraj, Aswin = 5, Jadeja, Mishra = 10}

Here, Dhoni is having an integer value 1, Kohli 2, Yuvraj 3, Aswin 5, Jadeja 6 and Mishra 10. That is, these names can be used wherever these values are needed.

String Literal

A character string literal is a sequence of zero or more characters enclosed in double-quotes, as in “xyz”. A $\text{UTF-8}$ string literal is the same, except prefixed by $u8$. A wide string literal is the same, except prefixed by the letter $L$, $u$, or $U$. All escape sequences applicable to a character constant is applicable for a string literal except that for $’$ an escape sequence is not mandatory. Any sequence of string literals will be combined into a single string literal during the translation phase of the compiler. Thus, “$abc$” “$de$” is equivalent to “abcde”. Another important property of string literal is that it cannot be modified and is usually stored in the $\text{RO}$ data segment.

char p[] = "hello world";
char *q = "hello world";

1 2	char p[] = "hello world"; char *q = "hello world";

Here, individual characters of p can be modified as the characters of the string literal “hello world” are copied to the memory allocated to $p$ which is $12$ bytes. But, individual characters of the content of $q$ can only be read and not modifiable as $p$ is pointing to a string literal, which is stored in the $\text{RO}$ data segment of the program as they are considered as constants. i.e.

p[2] = 'p'; //valid
char c = q[2]; //valid
q[3] = 'q'; //Invalid

p[2] = 'p'; //valid

char c = q[2]; //valid

q[3] = 'q'; //Invalid

The last statement causes segmentation fault.

Implicit Type Conversion

We can round off this chapter with an important point about implicit type conversion. Whenever we do an operation with different data types, the lower ranked data type is promoted to the higher ranked one, as, operations are meant to be performed on same types of data. For example when we add an $\text{int}$ and a $\text{float}$, the $\text{int}$ is promoted to $\text{float}$ and addition of two $floats$ takes place using two floating point registers. Similarly, when we add a $\text{char}$ and an $\text{int}$, the $8$ bits of char is made into $32$ bits (assuming $4$ byte size for $\text{int}$), by padding it with $0’s$.

One important point about implicit type conversion is that, it depends only on the source operands and is independent of the resultant data type. So, if we multiply two $integers$ and store in a $long$, the result will be calculated as $\text{int}$ (usually 4 bytes) and then stored in $long$ (usually 8 bytes). Another common example of this behavior is for division operation. When we divide two $integers$, the result will be $\text{int}$ only, even if we assign it to a $\text{float}$. So, in these cases the programmer has to explicitly cast one operand to the desired output type.

What exactly happens during type conversion?
Before reading the description below, think how it can happen- you won’t think wrong.

$unsigned$ to $signed$ or vice verse: There is no change in the representation in memory. When casting to signed, the most significant bit is taken as a sign bit which would otherwise be used for representing the number. So, this type casting is necessary during conditional checks as a negative number when type casted to unsigned will give a huge $\text{int}$ value.

$\text{char}$ to $\text{int}$: If $\text{int}$ is $4$ bytes- the top $3$ bytes are filled with sign bit if character is signed and with zero if character is unsigned, and bottom most byte is the same byte used to represent the $\text{char}$. The same holds for conversion from $\text{short int}$ to $\text{int}$ or from $\text{int}$ to $\text{long int}$

$\text{int}$ to $\text{char}$: Only the lowermost byte of the $\text{int}$ is taken and made to a $\text{char}$. So, if $\text{int}$ value is $511$, its char value will be $255$.

00000000 00000000 01111111 11111111 //511
//11111111 is 255

1 2	00000000 00000000 01111111 11111111 //511 //11111111 is 255

$\text{int}$ to $\text{float}$ or $\text{double}$: The fixed integer is converted to a representable floating point value. So, this might cause a change to entire bits used to represent the integer.

$\text{float}$ or $\text{double}$ to $\text{int}$: The integral part of the floating point value is saved as integer. The decimal part is ignored. For example, $5.9$ will be changed to $5$.

$\text{float}$ to $\text{double}$: The extra mantissa bits supported in $\text{double}$ are filled with $0$’s so are the extra exponent bits. The bits of float ($32$ of them) are used without modification.

$\text{double}$ to $\text{float}$: The extra mantissa bits supported in $\text{double}$ are truncated in floating representation so do the extra exponent fields. If the truncated exponent field were non zeroes, it might cause a change to other mantissa bits as well as the number would then need an approximation to fit in a float size.

Exercise Questions

Consider an implementation where int is 4 bytes and long int is 8 bytes. Which of the following initializations are correct?

#include <stdio.h>
int main()
{
   long int a = 0x7fffffff * 0x7ffffff;
   long int b = 0x7ffffffff * 0x7ffffff;
   long int c = 0x7fffffff * 0x7fffffff;
   long int d = 0x7fffffff * 0x7fffffffl;
   printf("a = %ld, b = %ld, c = %ld, d = %ld\n", a, b, c, d);
   return 0;
}

#include <stdio.h>

int main()

{

long int a = 0x7fffffff * 0x7ffffff;

long int b = 0x7ffffffff * 0x7ffffff;

long int c = 0x7fffffff * 0x7fffffff;

long int d = 0x7fffffff * 0x7fffffffl;

printf("a = %ld, b = %ld, c = %ld, d = %ld\n", a, b, c, d);

return 0;

}

Consider an implementation where int is 4 bytes and long int is 8 bytes. What will be the output of the following code?

#include <stdio.h>
int main()
{
   int i = 0;
   size_t a = sizeof i, b = sizeof (long);
   printf("a = %zd, b = %zd\n", a, b); //If %zd is given the compiler will automatically give it the correct type whether short, long or normal. 
//This is useful for special data types like size_t whose size is implementation specific

#include <stdio.h>

int main()

{

int i = 0;

size_t a = sizeof i, b = sizeof (long);

printf("a = %zd, b = %zd\n", a, b); //If %zd is given the compiler will automatically give it the correct type whether short, long or normal.

//This is useful for special data types like size_t whose size is implementation specific

   return 0;
}

1 2	return 0; }

What will be the output of the following code?

C

#include <stdio.h> int main() { unsigned int a = 5; if(a > -1) printf("5 is > -1\n"); return 0; }

1
2
3
4
5
6
7
8

#include <stdio.h>
int main()
{
   unsigned int a = 5;
   if(a > -1)
      printf("5 is > -1\n");
   return 0;
}
What will be printed by the following code?

C

#include <stdio.h> int main() { char buff[255] = "abc\ pee"; printf("%s", buff); return 0; }

1
2
3
4
5
6
7
8

#include <stdio.h>
int main()
{
   char buff[255] = "abc\
pee";
   printf("%s", buff);
   return 0;
}
What will be printed by the following code?

C

#include <stdio.h> #include <string.h> int main() { char buff[] = "abc" "hello"; printf("%zd\n", strlen(buff)); return 0; }

1
2
3
4
5
6
7
8

#include <stdio.h>
#include <string.h>
int main()
{
    char buff[] = "abc" "hello";
    printf("%zd\n", strlen(buff));
    return 0;
}
How can you print the following sentence exactly as it is by changing the assignment to buff? “Hello\\” “World\\”

C

#include <stdio.h> int main() { char buff[255] = "\0"; printf("%s", buff); return 0; }

1
2
3
4
5
6
7

#include <stdio.h>
int main()
{
    char buff[255] = "\0";
    printf("%s", buff);
    return 0;
}

Consider an implementation where int is 4 bytes and long int is 8 bytes. Which of the following initializations are correct?

#include <stdio.h>
int main()
{
    char *p = "Hello World";
    char q[] = "Hello World";
    printf("%zd %zd", sizeof p, sizeof *p);
    printf("\n");
    printf("%zd %zd", sizeof q, sizeof *q);
    return 0;
}

#include <stdio.h>

int main()

{

char *p = "Hello World";

char q[] = "Hello World";

printf("%zd %zd", sizeof p, sizeof *p);

printf("\n");

printf("%zd %zd", sizeof q, sizeof *q);

return 0;

}

What will be the output of the following code?

#include <stdio.h>
int main()
{
   {
      char a = 5;
      int b = 5;
      if(a == b)          
         printf("char and int compared equal\n");    }
   {
      int a = 5;
      long int b = 5;
if(a == b)
         printf("int and long compared equal\n");
   }
   {
      float a = 5.0;
      double b = 5.0;
      if(a == b)
         printf("float and double compared equal\n");
   }
   {
      float a = 5.2;
      double b = 5.2;
      if(a == b)
         printf("float and double again compared equal\n");
   }
   {
      float a = 5.2;
      if(a == 5.2)
         printf("float compared equal with constant\n");
   }
   {
      double a = 5.2;
      if(a == 5.2)
         printf("double compared equal with constant\n");
   }
   return 0;
}

#include <stdio.h>

int main()

{

char a = 5;

int b = 5;

if(a == b)

printf("char and int compared equal\n"); }

{

int a = 5;

long int b = 5;

if(a == b)

printf("int and long compared equal\n");

}

{

float a = 5.0;

double b = 5.0;

if(a == b)

printf("float and double compared equal\n");

}

{

float a = 5.2;

double b = 5.2;

if(a == b)

printf("float and double again compared equal\n");

}

{

float a = 5.2;

if(a == 5.2)

printf("float compared equal with constant\n");

}

{

double a = 5.2;

if(a == 5.2)

printf("double compared equal with constant\n");

}

return 0;

}

6,066 total views, 1 views today

C Coding Questions

April 15, 2016 by ibia Leave a Comment

Consider the following program:

#include <stdio.h> int main() { int a[10][20][30]={0}; printf("%ld",&a+1 - &a); return 0; }

1
2
3
4
5
6
7
8

#include <stdio.h>
int main()
{
    int a[10][20][30]={0};
    printf("%ld",&a+1 - &a);

    return 0;
}

What is the output of this program?

Consider the following program:

#include <stdio.h> 
int main()
{
    int a[10][20][30] = {0};
    int *b = a;
    int *c = a+1;
    printf("%ld", c-b);
 
    return 0;
}
What is the output of this program? (You may ignore compiler warnings)

#include <stdio.h>

int main()

{

int a[10][20][30] = {0};

int *b = a;

int *c = a+1;

printf("%ld", c-b);

return 0;

}

What is the output of this program? (You may ignore compiler warnings)

What is the output of the following program?

#include <stdio.h>
#include <stdlib.h>
int* fun();
 
int main()
{
    int *a = fun();
    printf("%d",*a);
 
    return 0;
}
int* fun()
{
    int *a =(int*) malloc(sizeof(int));
    *a = 10;
    return a;
}

#include <stdio.h>

#include <stdlib.h>

int* fun();

int main()

{

int *a = fun();

printf("%d",*a);

return 0;

}

int* fun()

{

int *a =(int*) malloc(sizeof(int));

*a = 10;

return a;

}

What is the output of the following program?

#include <stdio.h> int main() { int *a = fun(); printf("%d",a); return 0; } int fun() { int a = 10; return a; }

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
int main()
{
    int *a = fun();
    printf("%d",a);

    return 0;
}
int fun()
{
    int a = 10;
    return a;
}
What is the output of the following program?

#include <stdio.h> #include <string.h> int main() { char string[] = "Hello"; printf("%zu %zu",sizeof(string),strlen(string)); return 0; }

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
#include <string.h>

int main()
{
    char string[] = "Hello";
    printf("%zu %zu",sizeof(string),strlen(string));

    return 0;
}
What is the output of the following program?

#include <stdio.h> int main() { float a = 0.5; if(a == 0.5) printf("Yes"); else printf("No"); return 0; }

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main()
{
    float a = 0.5;
    if(a == 0.5)
        printf("Yes");
    else
        printf("No");

    return 0;
}
What is the output of the following program?

#include <stdio.h> #include <string.h> void foo(char *); int main() { char a[100] = {0}; printf("%zu %zu",sizeof(a),strlen(a)); return 0; }

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
#include <string.h>
void foo(char *);

int main()
{
    char a[100] = {0};
    printf("%zu %zu",sizeof(a),strlen(a));

    return 0;
}
What is the output of the following program? (Assume input is 10)

#include <stdio.h> int main() { int a; printf("%d",scanf("%d",&a)); return 0; }

1
2
3
4
5
6
7
8

#include <stdio.h>
int main()
{
    int a;
    printf("%d",scanf("%d",&a));

    return 0;
}

If the binary equivalent of 5.375 in normalised form is 01000000 10101100 00000000 00000000, what will be the output of the following program?

#include <stdio.h>
 
int main()
{
    float a=5.375;
    char *p;
    int i;
    p = (char*)&a;
    for(i=0; i<2; i++)
        printf("%x", (unsigned char)(p[i]^p[3-i]));
 
    return 0;
}

#include <stdio.h>

int main()

{

float a=5.375;

char *p;

int i;

p = (char*)&a;

for(i=0; i<2; i++)

printf("%x", (unsigned char)(p[i]^p[3-i]));

return 0;

}

What is the output of the following program?

#include <stdio.h> int main() { char str[] = {'a','b','c','\0'}; str[0] -= 32; printf("%s",str); return 0; }

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main()
{
    char str[] = {'a','b','c','\0'};
    str[0] -= 32;
    printf("%s",str);

    return 0;
}

Questions from Datatypes

Consider an implementation where int is 4 bytes and long int is 8 bytes. Which of the following initializations are correct?

#include <stdio.h>
int main()
{
   long int a = 0x7fffffff * 0x7ffffff;
   long int b = 0x7ffffffff * 0x7ffffff;
   long int c = 0x7fffffff * 0x7fffffff;
   long int d = 0x7fffffff * 0x7fffffffl;
   printf("a = %ld, b = %ld, c = %ld, d = %ld\n", a, b, c, d);
   return 0;
}

#include <stdio.h>

int main()

{

long int a = 0x7fffffff * 0x7ffffff;

long int b = 0x7ffffffff * 0x7ffffff;

long int c = 0x7fffffff * 0x7fffffff;

long int d = 0x7fffffff * 0x7fffffffl;

printf("a = %ld, b = %ld, c = %ld, d = %ld\n", a, b, c, d);

return 0;

}

Consider an implementation where int is 4 bytes and long int is 8 bytes. What will be the output of the following code?

#include <stdio.h>
int main()
{
   int i = 0;
   size_t a = sizeof i, b = sizeof (long);
   printf("a = %zd, b = %zd\n", a, b); //If %zd is given the compiler will automatically give it the correct type whether short, long or normal. This is useful for special data types like size_t whose size is implementation specific
   return 0;
}

#include <stdio.h>

int main()

{

int i = 0;

size_t a = sizeof i, b = sizeof (long);

printf("a = %zd, b = %zd\n", a, b); //If %zd is given the compiler will automatically give it the correct type whether short, long or normal. This is useful for special data types like size_t whose size is implementation specific

return 0;

}

What will be the output of the following code?

#include <stdio.h> int main() { unsigned int a = 5; if(a > -1) printf("5 is > -1\n"); return 0; }

1
2
3
4
5
6
7
8

#include <stdio.h>
int main()
{
   unsigned int a = 5;
   if(a > -1)
      printf("5 is > -1\n");
   return 0;
}
What will be printed by the following code?

#include <stdio.h> int main() { char buff[255] = "abc\ pee"; printf("%s", buff); return 0; }

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int main()
{
   char buff[255] = "abc\
pee";
   printf("%s", buff);
   return 0;
}
What will be printed by the following code?

#include <stdio.h> int main() { char buff[255] = "\0"; printf("%s", buff); return 0; }

1
2
3
4
5
6
7
8

#include <stdio.h>

int main()
{
    char buff[255] = "\0";
    printf("%s", buff);
    return 0;
}

What will be the output of the following code? (Assume a 64 bit machine/compiler)

#include <stdio.h>
int main()
{
    char *p = "Hello World";
    char q[] = "Hello World";
    printf("%zd %zd", sizeof p, sizeof *p);
    printf("\n");
    printf("%zd %zd", sizeof q, sizeof *q);
    return 0;
}

#include <stdio.h>

int main()

{

char *p = "Hello World";

char q[] = "Hello World";

printf("%zd %zd", sizeof p, sizeof *p);

printf("\n");

printf("%zd %zd", sizeof q, sizeof *q);

return 0;

}

What will be the output of the following code?

#include <stdio.h>
int main()
{
   {
      char a = 5;
      int b = 5;
      if(a == b)          
         printf("char and int compared equal\n");    }
   {
      int a = 5;
      long int b = 5;
if(a == b)
         printf("int and long compared equal\n");
   }
   {
      float a = 5.0;
      double b = 5.0;
      if(a == b)
         printf("float and double compared equal\n");
   }
   {
      float a = 5.2;
      double b = 5.2;
      if(a == b)
         printf("float and double again compared equal\n");
   }
   {
      float a = 5.2;
      if(a == 5.2)
         printf("float compared equal with constant\n");
   }
   {
      double a = 5.2;
      if(a == 5.2)
         printf("double compared equal with constant\n");
   }
   return 0;
}

#include <stdio.h>

int main()

{

char a = 5;

int b = 5;

if(a == b)

printf("char and int compared equal\n"); }

{

int a = 5;

long int b = 5;

if(a == b)

printf("int and long compared equal\n");

}

{

float a = 5.0;

double b = 5.0;

if(a == b)

printf("float and double compared equal\n");

}

{

float a = 5.2;

double b = 5.2;

if(a == b)

printf("float and double again compared equal\n");

}

{

float a = 5.2;

if(a == 5.2)

printf("float compared equal with constant\n");

}

{

double a = 5.2;

if(a == 5.2)

printf("double compared equal with constant\n");

}

return 0;

}

Questions from Pointers

What will be the output of the following code?

#include <stdio.h> int main() { int a = 5; int* p = &a; printf("%d", ++*p); }

1
2
3
4
5
6
7
8

#include <stdio.h>

int main()
{
  int a = 5;
  int* p = &a;
  printf("%d", ++*p);
}
What will be the output of the following code?

#include <stdio.h> int main() { char a[] = "Hello World"; char* p = &a; printf("%s", p+2 ); }

1
2
3
4
5
6
7
8

#include <stdio.h>

int main()
{
  char a[] = "Hello World";
  char* p = &a;
  printf("%s", p+2 );
}
What will be the output of the following code?

#include <stdio.h> int main() { int a; int* p = &a; printf("%zu", sizeof( *(char*)p )); }

1
2
3
4
5
6
7
8

#include <stdio.h>

int main()
{
  int a;
  int* p = &a;
  printf("%zu", sizeof( *(char*)p  ));
}

Is the following code legal?

#include <stdio.h>
 
int main()
{
  int a = 1;
  if((char*)  &a)
  {
    printf("My machine is little endian");
  }
  else
  {
     printf("My machine is big endian\n");
  }
}

#include <stdio.h>

int main()

{

int a = 1;

if((char*) &a)

{

printf("My machine is little endian");

}

else

{

printf("My machine is big endian\n");

}

What will be the output of the following code?

#include <stdio.h> int main() { int *a = (int*) 1; printf("%d", a); }

1
2
3
4
5
6
7

#include <stdio.h>

int main()
{
int *a = (int*) 1;
printf("%d", a);
}
What will be the output of the following code?

#include <stdio.h> int main() { int a = 1, *p, **pp; p = &a; pp = p; printf("%d", **pp); }

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int main()
{
  int a = 1, *p, **pp;
  p = &a;
  pp = p;
  printf("%d", **pp);
}
What will be the output of the following code?

#include <stdio.h> int main() { int a = 1, *p, **pp; p = &a; pp = p; printf("%d", *pp); }

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int main()
{
  int a = 1, *p, **pp;
  p = &a;
  pp = p;
  printf("%d", *pp);
}

Assuming a little endian machine, what will be the output of the following program?

#include <stdio.h>
 
fun(int a)
{
  char *arr[] = {"0000", "0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"};
  unsigned char* p = (unsigned char*) &a ;
  p+=3;
  int i;
  for(i = 0; i < sizeof a; i++) { int d = (*p)>>4; 
    printf("%s", arr[d]);
    d = (*p) & 0xf;
    printf("%s ", arr[d]);
    p--;
  }
}
 
int main()
{
 int a;
 scanf("%d", &a);
 fun(a);
}

#include <stdio.h>

fun(int a)

{

char *arr[] = {"0000", "0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"};

unsigned char* p = (unsigned char*) &a ;

p+=3;

int i;

for(i = 0; i < sizeof a; i++) { int d = (*p)>>4;

printf("%s", arr[d]);

d = (*p) & 0xf;

printf("%s ", arr[d]);

p--;

}

int main()

{

int a;

scanf("%d", &a);

fun(a);

}

Some codes

What is the following function doing?

int foo(int n) { int sum = 0; while(n > 0) { n = n & n-1; sum++; } return sum; }

1
2
3
4
5
6
7
8
9
10

int foo(int n)
{
    int sum = 0;
    while(n > 0)
    {
        n = n & n-1;
        sum++;
    }
    return sum;
}

What is the following function doing?

int foo(int a, int b)
{
    int c = a, d = b;
    while(a != b)
    {
        if(a &lt; b)
            a = a+c;
        else
            b = b+d;
    }
    return a;
}

int foo(int a, int b)

{

int c = a, d = b;

while(a != b)

{

if(a < b)

a = a+c;

else

b = b+d;

}

return a;

}

What is the following function doing?

int foo( int a, int b) { int c = a-b; c = c&(0x80000000); return (!c)*a +(!!c)*b; }

1
2
3
4
5
6

int foo( int a, int b)
{
    int c = a-b;
    c = c&(0x80000000);
    return (!c)*a +(!!c)*b;
}

What is the following function doing?

unsigned fun(unsigned a, unsigned b)
{
    int i;
    unsigned  j = 0;
    for(i = 0; i &lt; 32; i++)
    {
        j &lt;&lt;= 1;
        j += !!(a &amp; 0x80000000);
        a &lt;&lt;= 1; if(j &gt;=b)
        {
            j -= b;
            a++;
        }
    }
    return a;
}

unsigned fun(unsigned a, unsigned b)

{

int i;

unsigned j = 0;

for(i = 0; i < 32; i++)

{

j <<= 1;

j += !!(a & 0x80000000);

a <<= 1; if(j >=b)

{

j -= b;

a++;

}

return a;

}

What is the following function doing?

unsigned fun(unsigned int a)
{
    unsigned int i, x = 0, y = 0, z = 0;
    for(i = 0; i &lt; 16; i++)
    {
       	y &lt;&lt;= 2;
       	y += !!(a &amp; 0x80000000) &lt;&lt; 1;
       	y += !!(a &amp; 0x40000000);
       	a &lt;&lt;= 2;
       	x = x + (x&amp;1);
       	x &lt;&lt;= 1;
       	z &lt;&lt;= 1;
       	if(x + 1 &lt;= y)
       	{
            x++;
            z++;
	    y-=x;
        }
    }
    return z;
}

unsigned fun(unsigned int a)

{

unsigned int i, x = 0, y = 0, z = 0;

for(i = 0; i < 16; i++)

{

y <<= 2;

y += !!(a & 0x80000000) << 1;

y += !!(a & 0x40000000);

a <<= 2;

x = x + (x&1);

x <<= 1;

z <<= 1;

if(x + 1 <= y)

{

x++;

z++;

y-=x;

}

return z;

}

Write the code to dynamically allocate a 2-D array of size m x n.
Declare a pointer to a function accepting an integer and returning void.
Write the condition so that the below code outputs Hello World.

#include <stdio.h> int main() { if() { printf("Hello "); } else { printf("World\n"); } return 0; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
int main()
{
    if()
    {
printf("Hello ");
    }
    else
    {
printf("World\n");
    }

    return 0;
}
Write a one line code to check if a number is a power of 2.
Write a one line code to invert the last four bits of an integer.

10,161 total views, no views today

Data Structures

July 2, 2015 by Arjun Suresh 7 Comments

Webpage for Programming

Syllabus

Arrays, Stacks, Queues
Linked Lists
Trees, Binary search trees, Binary heaps.
Graphs

Book

54,264 total views, 21 views today

Skip links

Programming & DS

What a C program does?

Digital Circuits

Computer Organization

Computer Architecture

Segmentation Fault

Share this:

Like this:

Best option for System Programming

on 64 bit machines

Other architectures

For those who don’t want to use Ubuntu (I don’t know why?) and want to use only Windows

Share this:

Like this:

Contents

* Operator

Example

Pointer Arithmetic

Does a pointer have memory?

Example

Assigning values to pointers

Example

Problems with pointers

Exercise Questions

Share this:

Like this:

Content

A little about C standards

Data types

Constants and variables

Constant Types

Integer Constant

Floating Constant

Character Constant

Enumeration Constant

String Literal

Implicit Type Conversion

Exercise Questions

Share this:

Like this:

Questions from Datatypes

Questions from Pointers

Some codes

Share this:

Like this:

Syllabus

Book

Video

Web Links

Previous Year Questions

Important Questions

GATE CSE Discussions

Share this:

Like this:

What a $C$ program does?