A simple C program

Let's talk about simplicity. And let's look at a simple C program today. Why not, every day we deal with complex problem, so let's talk about a simple C program now. Here is the program;

main()

{

    char *p1="name";

    char *p2;

    p2=(char*)malloc(20);

    memset (p2, 0, 20);

    while(*p2++ = *p1++);

    printf("%s\n", p2);

}

Well, what does this program do. This is the topic of today's blog.

Ans:

Looks like this program output's the string name , but that's not true.

What do you think about this program?

Write your comments about it.

All about C++ templates

Templates in C++ can be of class template or function template.
A template is used as a mechanism to generalize the parameter type we pass to either the class or function. This extends the function overloading concept of C++. Template takes the C++ concept of polymorphism to the next level.


Here is a example of function templates:
Let's say we have a swap function that swaps two variables of type T.

void f(int a, int b, float m, float n)
{
    swap(a, b);      //swap two integer values
    swap(m, n);      //swaps two float values
}

We can write a template function to do this as below:

template <class T>
void swap (T &x, T &y)
{
    T temp = x;
    x = y;
    y = T;
}

Similarly we have class template where we can pass any type of parameter using the template T.

template < class T>
class vector
{
     T *v; //type T vector, T can be int, float, anything
     int size;
   public:
     vector (int m)
     {
     v = new T[size = m]; // v is an array of type T
     //initialize the array
       for (int i = 0; i < size; i++)
         v[i] = 0;
    }

}


This is an example of a class vector which initialize an object of type T of array. Invoke it this way:
     vector < int> v1(10);    //a vector class of int
     vector < float> v2(20);    //a vector class of float



Q1. Find the o/p of the code snippet:
template < class T, int l=7> class Foo {
     static const T k = l;
     int q;

   public:
     Foo(int x = l) : q(x)
     { }
     T GetQ() const { return q; }
}

void f() {
     Foo < long, 9> foo(10);
     std :: cout << foo.GetQ();

}

Ans:
Explaination:
Default values for template parameters

Template parameters may have default values, and when instantiating the template these values can be omitted. Here’s an example:

template <typename T=int, int N=10>
class Foo {
};

Foo<float, 42> foo1;
Foo<double> foo2;
Foo<> foo3;

Note specifically the strange syntax for the definition of foo3, which means that it instantiates the Foo template with all parameters assigned their default values. Default values may only be specified for class templates.

Q2. What is STL?
Ans: STL is the C++ Standard Template Library. Instead of writing your own, you can use templates from STL just like other library functions that we use from any other C/C++ library. It is a collections of class templates and function templates. We sahould use template library as it is bug free rather than writing our own like inventing the wheel again.


In tehnical terms:
The Standard Template Libraries (STL's) are a set of C++ template classes to provide common programming data structures and functions such as doubly linked lists (list), paired arrays (map), expandable arrays (vector), large string storage and manipulation (rope), etc. The STL library is available from the STL home page. This is also your best detailed reference for all of the STL class functions available. STL can be categorized into the following groupings:

Here is the greatest post about C++ Templates:
http://eli.thegreenplace.net/2011/04/22/c-template-syntax-patterns/

Q3. What is partial specialization or template specialization?

Q4. How can you force instantiation of a template?

Q5. What is an iterator?

Q6. What is an algorithm (in terms of the STL/C++ standard library)?

Hello World!

How about compiling a C programming right from the browser itself.
Here it is:

Best C/C++/Data Structure Programming books

C/C++ Programming Questions This blog is for C/C++ Programming

Here is my collection of some of the best Programming books.

No 1 has to be this:

Then comes the rest of them.
When it comes to data structure there is a book written in simple English, very easy to comprehend the basic fundamentals of computer science.

There are couple of C++ books. But I find this to be the best:


        C++
        How to Program by Deitel and Deitel


And here a list of best Linux programming books:
a) Linux Kernel

b) Linux Device Driver Programming

Enjoy, happy reading.

Regards,
Kongkon

Free Linux Machine with C compiler

Hello World!
Many of us wanted their own Linux machine to do some C programming or at least to get a feel of the Linux Operating System.

Here is a Linux machine which can be accessible over the internet free of cost only for you :-). 

Just type the following URL in the browser and here you are in your own Linux machine:


http://bellard.org/jslinux/

This is an amaizing work by Bellard. There is also a clipboard facility to copy/paste your work back and forth between your local system and the Linux machine.

Copy your file to the clipboard:

cat myfile > /dev/clipboard

Explore this machine, and I am sure you will have lots of fun. The best part is that there is a C Compiler to test your own C programs.
It's a tiny version of a C compiler called "tcc".


To have a deep dive into the booting process of this OS, look at the booting sequence:

Linux version 2.6.20 (bellard@voyager) (gcc version 3.4.6 20060404 (Red Hat 3.4.6-9)) #2 Mon Aug 8 23:51:02 CEST 2011
BIOS-provided physical RAM map:
sanitize start
sanitize bail 0
 BIOS-e801: 0000000000000000 - 000000000009f000 (usable)
 BIOS-e801: 0000000000100000 - 0000000001000000 (usable)
16MB LOWMEM available.
Entering add_active_range(0, 0, 4096) 0 entries of 256 used
Zone PFN ranges:
  DMA             0 ->     4096
  Normal       4096 ->     4096
early_node_map[1] active PFN ranges
    0:        0 ->     4096
On node 0 totalpages: 4096
  DMA zone: 32 pages used for memmap
  DMA zone: 0 pages reserved
  DMA zone: 4064 pages, LIFO batch:0
  Normal zone: 0 pages used for memmap
DMI not present or invalid.
Allocating PCI resources starting at 10000000 (gap: 01000000:ff000000)
Detected 3.333 MHz processor.
Built 1 zonelists.  Total pages: 4064
Kernel command line: console=ttyS0 root=/dev/ram0 rw init=/sbin/init notsc=1
Initializing CPU#0
Disabling TSC...
PID hash table entries: 64 (order: 6, 256 bytes)
Console: colour dummy device 80x25
Dentry cache hash table entries: 2048 (order: 1, 8192 bytes)
Inode-cache hash table entries: 1024 (order: 0, 4096 bytes)
Memory: 11956k/16384k available (1265k kernel code, 4040k reserved, 324k data, 124k init, 0k highmem)
virtual kernel memory layout:
    fixmap  : 0xffffc000 - 0xfffff000   (  12 kB)
    vmalloc : 0xc1800000 - 0xffffa000   ( 999 MB)
    lowmem  : 0xc0000000 - 0xc1000000   (  16 MB)
      .init : 0xc0290000 - 0xc02af000   ( 124 kB)
      .data : 0xc023c503 - 0xc028d854   ( 324 kB)
      .text : 0xc0100000 - 0xc023c503   (1265 kB)
Checking if this processor honours the WP bit even in supervisor mode... Ok.
Calibrating delay using timer specific routine.. 20.22 BogoMIPS (lpj=101116)
Mount-cache hash table entries: 512
CPU: After generic identify, caps: 00000010 00000000 00000000 00000000 00000000 00000000 00000000
Intel Pentium with F0 0F bug - workaround enabled.

CPU: After all inits, caps: 00000000 00000000 00000000 00000000 00000000 00000000 00000000
Compat vDSO mapped to ffffe000.
CPU: Intel Pentium MMX stepping 03
Checking 'hlt' instruction... OK.
NET: Registered protocol family 16
Setting up standard PCI resources
NET: Registered protocol family 2
IP route cache hash table entries: 1024 (order: 0, 4096 bytes)
TCP established hash table entries: 1024 (order: 0, 4096 bytes)
TCP bind hash table entries: 512 (order: -1, 2048 bytes)
TCP: Hash tables configured (established 1024 bind 512)
TCP reno registered
checking if image is initramfs...it isn't (bad gzip magic numbers); looks like an initrd
Freeing initrd memory: 2048k freed
Total HugeTLB memory allocated, 0
io scheduler noop registered
io scheduler anticipatory registered
io scheduler deadline registered
io scheduler cfq registered (default)
Real Time Clock Driver v1.12ac
JS clipboard: I/O at 0x03c0
Serial: 8250/16550 driver $Revision: 1.90 $ 4 ports, IRQ sharing disabled
serial8250: ttyS0 at I/O 0x3f8 (irq = 4) is a 16450
RAMDISK driver initialized: 16 RAM disks of 4096K size 1024 blocksize
loop: loaded (max 8 devices)
TCP cubic registered
NET: Registered protocol family 1
NET: Registered protocol family 17
Using IPI Shortcut mode
Time: pit clocksource has been installed.
RAMDISK: ext2 filesystem found at block 0
RAMDISK: Loading 2048KiB [1 disk] into ram disk... | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ done.
EXT2-fs warning: maximal mount count reached, running e2fsck is recommended
VFS: Mounted root (ext2 filesystem).
Freeing unused kernel memory: 124k freed
 

Enjoy this. We shall explore more later.

RIP Dennis Ritchie

Dennis Ritchie

 

The great Dennis Ritchie, the creator of C Programming Language, the reason behind which this programming blog exist today, died on 12th October 2011, at the age of 70.  

Here is a small C program as a tribute to Dennis Ritchie.

 

main() {

        printf("1941: Hello World!\n");

        printf("2011: RIP Dennis Ritchie\n");

}

Test your own C Programming skills

Hello World!

Good morning C programmers. Here is a compilation of couple of C and C++ questions to test your C/C++ programming knowledge. Most of the time you will be facing similar questions in job interviews for Software engineer or programmer not only at the fresher level but also at a very senior level. Many companies expect you to be hands on even at senior level. C is a programming language which is easy and at the same time extremely difficult if asked about complex pointer related questions. So, one has to be extremely careful in answering such questions.







Q1. Find the o/p:
main()
{
    char *ptr="hello";
    char ary[]="world";

printf("PTR: &ptr=%x, ptr=%x, *ptr=%x, ptr[0]=%x\n", &ptr,ptr, *ptr, ptr[0]);
printf("ARY: &ary=%x,ary=%x, *ary=%x, ary[0]=%x\n", &ary, ary, *ary, ary[0]);
}

Ans:

PTR: &ptr=bfb86990, ptr=8048524, *ptr=68, ptr[0]=68
ARY: &ary=bfb8698a,ary=bfb8698a, *ary=77, ary[0]=77

---

Q2. Find the o/p:
main()
{
    struct node {
        char a;
        int b; 
        short c;
        struct node next;
    }n1;   

printf("Ans1:%d\n", sizeof(n1));

return 0;
}

Ans:

This program will not compiler.
Reason: The compiler can't figure out the space needed for the structure n1.
[kongkond@jorhat ~]$ gcc Q2.c
Q2.c: In function ‘main’:
Q2.c:7: error: field ‘next’ has incomplete type

---

Q3. Find the o/p:
main()
{
    struct node {
        char a;
        int b; 
        short c;
        struct node *next;
    }n1;   

printf("Ans1:\n\t node=%x\n \t node+2=%x\n", (char *)&n1, (char *)&n1+2);
printf("Ans2:%d\n", sizeof(n1));

return 0;
}
Ans:

Ans1:
     node=bfcc5c94
      node+2=bfcc5c96
Ans2:16

---

Q4. What is the difference between fopen() and open()? When do you choose to use one over the other?

Ans:

FILE * fopen(const char *restrict filename, const char *restrict mode);
--Upon successful completion fopen() returns a FILE pointer.  Otherwise, NULL is returned and the global variable errno is set to indicate the error.


int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
--Given a pathname for a file, open() returns a file descriptor, a small, non-negative integer for use in subsequent system calls (read(2), write(2), lseek(2), fcntl(2), etc.). The file descriptor returned by a successful call will be the lowest-numbered file descriptor not currently open for the process.

---

Q5. Find the o/p:
main()
{
if(!printf("Hello ")){}
else
printf("World!");
}
Ans:

Hello World!

---

Q6. Find the o/p:
main()
{
struct i{
int a;    //4
double b;    //8
char * c;    //4
char d[7];    //8
short e;    //4
int f;    //4
};
printf("sizeof(i)= %d", sizeof(struct i));
}
Ans:

 4+8+4+8+4+4=32

---

Q6.1. Find the o/p:
main()
{
struct i{
int a;    //4
double b;    //8
char * c;    //4
char d[3];    //4
short e;    //4
int f;    //4
};
printf("sizeof(i)= %d", sizeof(struct i));
}
Ans:

 4+8+4+4+4+4=28

---

Q7. Find the o/p:
# include < stdio.h >
void main()
{
printf(NULL) ;
return ;
}
Ans:

> ./a.out
>

---

Q8. Find the o/p:
# include < stdio.h >
void main()
{
int i = 0;
printf(i) ;
return ;
}
Ans:

In newer gcc compiler this will not compile. In older ones:
> ./a.out
>

But,
# include < stdio.h >
void main()
{
int i = 0;
printf("%f\n", i) ;
return ;
}

Ans: random number like:
-0.008430

And the result of the following will be like this:
# include < stdio.h >
void main()
{
int i = 0;
printf("%f %d\n", i) ;
return ;
}
Ans:random number like:
-0.008430   134513785

---

Q9. Find the o/p:
#include <stdio.h>
void main()
{
printf("%s",NULL) ;
return ;
}
Ans:

> ./a.out
(null)

But,
#include <stdio.h>
void main()
{
int i = -10;
printf("%s\n",i) ;
return ;
}
will result in "Segmentation fault" if the value of i is other than zero.

---

Q10. Find the o/p of this last one:
main()
{
printf("%%",7);
}
Ans:

Try yourself

---

Q11. How do I declare an array of N pointers to functions returning pointers to functions returning pointers to characters?
Ans:

Well, first you need to know how to declare an array of N items of type T - that's

T foo[N];

Now you need to look at how to declare a pointer to function returning something, say, an object of type S. That's like this:

S (*bar)();

Now assume that S is ``pointer to function returning pointer to char''. We get

(char *) (*)() (*bar)().

So, the whole thing turns out to be (with appropriate parentheses)

(((char)(*))((*)())(((*)((foo)))())([(N)]));

If your compiler complains, break this down into subexpressions.

To call it, just use

foo[i]();

This works because, in C, declaration reflects use, but it's one of those weird distorted mirrors.

---

Q12. What is asmlinkage and what is it's use?
Ans:

"asmlinkage" is defined, for example, in the header file
"include/asm-i386/linkage.h" as
__attribute__((regparm(0)))
that tells compiler put all function parameters in the stack (i.e.
disables call optimization).
In simple terms, a) you are using assembly code using asmlinkage, and b) all the function parameters are pushed into the stack and optimization is disabled for this purpose.
For more details check this link.

---

Q13. What is output?
main()
{
printf("%x",-1<<4); }

Ans:

[root@monday kongkon]# gcc 2.c
2.c: In function âmainâ:
2.c:3: warning: incompatible implicit declaration of built-in function âprintfâ
[root@monday kongkon]# ./a.out
fffffff0[root@monday kongkon]#

(1)10=(0000 0000 0000 0001)2
(-1)10=(2's complement of binary 1)=(1's complement of 1 added with 1) =(1111 1111 1111 1110 + 1 )2=(1111 1111 1111 1111)2
Now,
(-1)10 << 4 = (1111 1111 1111 0000)2=(F F F 0)16 Note: In Computer, Negative numbers are represented in 2's complement form, which is 1's complement +1.

Link to the earlier post: Test your programming skills.

Enjoy yourself.
Regards,
Kongkon

---

Single Linked List using C

Here is a single linked list data structure using C Language:


#include

struct node {
        int data;
        struct node * next;
};

struct node *first = NULL;

int menu();

struct node * insert_node(int data);
struct node * delete_node(int data);
int count_node(struct node *);
int traverse_list(struct node *);


int menu()
{
int item = 0;

return item;
}

/*
* This routine will insert a new node to the left hand side of a linked list. And make this new node as the first node after insertion.
*/
struct node * insert_node(int data)
{
        struct node * temp = NULL;

        temp = (struct node *)malloc(sizeof(struct node));
        if (!temp)
                printf("Not enough memory in the system\n");

        // insert data;
        temp->data = data;

        if(first == NULL)
        {
                first = temp;
                temp->next = NULL;
                //printf("data=%d\n", temp->data);
        }
        else
        {
                temp->next = first;
                first = temp;
        }

return first;
}
/*
delete_node(int data) deletes the first node from the singly linked list where the data matches, and returns the starting of the list.
*/
struct node * delete_node(int data)
{
struct node * current = first, *prev;
//search the list for the first occurance of "data". If no node with "data" found then the list remains the same.

        while(current && current->data!=data)

        {

                prev = current;

                current=current->next;

        }

        prev->next = current->next;

        free(current);

return first;

}

int traverse_list(struct node *list_head)

{

        struct node * current, *prev;

        if (!first)

                printf("Empty list\n");

        current = first;

        prev = current->next;

        printf("\n\nList = ");

#if 1

        while(current)

        {

                printf("\t %d", current->data);

                current = current->next;

        }

#endif

        printf("\n\n");

}

main()

{

insert_node(30);

insert_node(40);

insert_node(50);

insert_node(60);

insert_node(70);

traverse_list(first);

delete_node(50);

traverse_list(first);

return 0;

}

Result of running this program:

kongkon@Linkat-Luidia:~/sea> ./a.out

List =   70      60      50      40      30

List =   70      60      40      30