The exact procedure would depend on the compiler, though will not vary widely. Since we work extensively on Linux, we will show you how to do so using the GCC compiler in Linux:

The simplest way of combining multiple C programs to create a single executable is:

$gcc 1.c 2.c 3.c

The files 1.c, 2.c and 3.c will be individually compiled, and the generated object codes will be linked together and with the standard library to create an executable called a.out. Note that on some systems, the command to compile is cc instead of gcc, but without any other difference.

The long cut for doing the same is:

$gcc -c 1.c

$gcc -c 2.c

$gcc -c 3.c

$gcc 1.o 2.o 3.o

In this case, we individually compile (-c stands for ‘only compile’) each of the 3 files, with the object codes being written on to corresponding .o files. We then ask gcc to link these object codes together along with the standard library. An advantage of this long cut is that if we change a few files, we need to only recompile those files we had changed and link the object codes together, without having to unecessarily recompile all files. Of course, an even better technique is to use makefiles, which hopefully will be covered by a separate article in this blog later.

Many IDE allow the user to create a “project” comprising of C files, and a “build” option to compile all changed files and link the object codes together, giving rise to a single executable.

Q

What would be the size of int and int* on a Linux 64-bit environment? I expect both to be same but am getting different sizes… need some explanation!

-Sumit Maurya

Incidentally, I recently posted an article on our blog about sizes of integral types, with a link posted on our facebook page.

To clarify, the size of int is dependent on the compiler, and is supposed to match the machine word size. The size of that is assumed by the compiler. Compilers may give 4 bytes for int, because long can be 8 bytes wide – it is purely a decision of the compiler vendor!

The size of int*, however, cannot be purely the choice of the vendor. Pointers are addresses, and given the fact that it is a 64-bit environment, addresses have to be 64-bits wide. Thus, the size of int* (or any pointer) will be 8 bytes.

1. The size of char should be at least 1 byte (most implementations will have sizeof(char)=1)

2. The size of short should be less than or equal to the size of int, and should be at least 2 bytes (most implementations will have sizeof(short)=2)

3. The size of int should be the machine word size (the optimal size that the system can handle at one go). Thus, a 16-bit compiler will have sizeof(int)=2 (16 bits = 2 bytes) whereas a 32-bit compiler will have sizeof(int)=4 (32 bits = 4 bytes)

4. The size of long should be greater than or equal to size of int, and should be at least 4 bytes (most implementations will have sizeof(long=4)

Thus, the following condition will always hold good, no matter which C compiler you use:

sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)

Typical values are shown below:

Yes!

Most people seem to think that these two terms are inter-changeable: they are not! There is a very clear distinction between a variable definition and variable declaration.

A variable definition defines the variable to the compiler. In the process, it specifies the data type, storage class and initialization. Most importantly, a variable definition results in memory allocation by the compiler. Thus, a variable once defined can never be re-defined.

Examples of variable definition:

int x;
int x=10;
auto int x;
register int x;
static int x;
extern int x=10;

A variable declaration merely declares the existence of a variable to the compiler and documents it’s data type. Thus, the compiler realises that there will be a variable of that name and data type defined elsewhere. The declaration does not result in any memory allocation, and hence declarations can be repeated multiple times without any problem, though there is no need to.

There is only one way a variable can be declared in C:

extern int x;

This declaration tells the compiler that there is a variable called x of type int which will be defined elsewhere (probably even in a different C program).

Summary: variable definitions result in memory allocation and cannot be repeated whereas variable declarations do not result in memory allocation and can be safely repeated.

Dennis Ritchie (1941-2011)

C has an enormous history before it could become popular, and has already become perhaps the most popular language on this planet! A very small percentage of developers and students seem to know how the language evolved, and hence this article.

We start from the early 1960s, when the University of Cambridge invented a language called Cambridge Programming Language (CPL). With the involvement of the University of London, it was then renamed Combined Programming Language, though the abbreviation remained unchanged. In fact, it was also nicknamed Cambridge Plus London, retaining the same abbreviation! Even though the language was announced in 1963, it’s compiler was ready only by 1970 due to slow development. History did not wait till 1970 though, and the language slowly and silently disappeared in the 1970s.

In 1966, Martin Richards from University of Cambridge modified CPL in order to make it easy to develop compilers, and that resulted in the birth of BCPL (Basic Combined Programming Language). BCPL is also history and is no longer used. BCPL is also nicknamed Before C Programming Language.

In 1969, when MULTICS was dropped by AT&T Bell Labs, Ken Thompson and Dennis Ritchie tried their hand at developing a scaled-down version of MULTICS, which was named UNICS by Brian Kernighan, and later spelled UNIX – the very famous operating system. In order to develop MULTICS and UNIX, Ken Thompson stripped down BCPL, inventing a language called B. While the first version of UNIX was written in assembly language, it was rewritten in B.

Due to the frustrating experiences of writing UNIX in B, Dennis Ritchie proceeded to improvise B, inventing a highly portable language in 1972 which was called C, because it was an improvement over B! UNIX was then rewritten all over again in C, and remains that way till this day. While B is almost history, C is very popular and a variety of programming languages have been invented based on it since then.

When the language was originally developed, there were no standard rules that all compilers for the language had to implement. Guidance was taken from the popular book “The C Programming Language” written by Dennis Ritchie and Brian Kernighan. This formed an unofficial standard called K&R C. The first formal standard for C was published by the American National Standards Institute in 1989 called ANSI C (also called C89). International Organisation for Standardization then passed it as an international standard in 1990 under the name C90. This was then revised in 1999 (C99) and again in 2011 (C11).

The successor of C was supposed to be C++, designed by Bjarne Stroustrup in 1983. The name was so given because of the “++” increment operator of C, as an indication that this is the next version of C and the future of C. The most important feature added in C++ was support for Object Oriented Programming. The previous names for this language were C with classes and new C. While there was a lot of expectation that C will get replaced by C++, C continues to exist on it’s own despite C++’s success and popularity, probably because C continues to be more efficient, some of C++’s non-OOP features were incorporated in C and OOP is not required in all situations.

C++ was supposed to be superseded by D, a language invented by Walter Bright in 2001 that boasts of Java and C# like features, making it easier for programmers to code and improving the reliability of the code, but again D could not challenge C++, partly due to the fact that the area was already taken up by Java and C#.

This was a brief and most pertinent history and future of C. There were many more incidents, people and languages involved, and a lot of politics too! With the level of permeation that C has shown, it is currently very difficult to visualise a day when C becomes history!

In DOS, if you write C/C++ programs using Turbo C/C++, you will need to select a memory model for the application. The memory model basically specifies the number of segments in memory for code, data and stack and has an effect on all pointers used in the program.

continue reading "Memory Models and Types of Pointers"

Every running program (process) occupies some memory for its code and data. Linux follows a particular methodology for assigning memory addresses to various parts of a program. Linux assigns a “segment” to each of the following, where a segment can be defined as a single memory block of variable size:
continue reading "Memory Layout for C Programs in Linux"

Question:

Hi! I am designing a game in C. The objective of the game is to arrange numbers in order

____7________8________4
____1________6________3
____2________5________0

by swapping them with 0

For any possible combination of these numbers…(i.e., arranging them in different possible combinations)..can we get answer…..(i.e., arrange them in order).
is it possible…..?

continue reading "Challenge: Number Puzzle Game in C"

C learners are generally pretty comfortable with the str… series of functions:

1. strlen()
2. strcpy()
3. strcat()
4. strcmp()
5. strlwr()
6. strupr()

However, I generally find a very poor awareness of the mem… series of functions:

1. memcpy()
2. memmove()
3. memset()
4. memchr()

continue reading "Article: The mem… Functions!"