devkuma – C

C Language | Computer System Development

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

C Language | Computer System Development | Program Structure

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains how programs work and introduces types of software such as applications and operating systems.

Software and Programming

If you already have programming experience in a language other than C and understand what a program is, you can skip this section.

Although computer systems differ, every computer runs according to logical information called software. Software consists of programs that record the procedures and information a computer must process. After a computer boots, programs are loaded into the CPU and continue running according to defined procedures until the computer is turned off. A computer cannot operate without software.

Programs read and processed by the CPU consist of numeric data called machine code. Each value has a meaning defined by the CPU. The CPU reads an instruction, interprets it, and executes it. The operation of determining the location of the next instruction and retrieving it is called a fetch. A working program repeatedly performs this fetch cycle and the instruction execution cycle.

Most software written by programmers, however, is not designed to run immediately after the computer is powered on. An application, also called application software or an application program, is software created for a specific purpose such as business processing. How does a computer reach the point where it can run application software?

When the computer is powered on, a predefined program runs first. After hardware initialization is complete, the computer reads a program from a designated storage device. This series of operations is called booting. Only a small number of programmers need detailed knowledge of the boot process.

After the boot process completes, the operating system starts. An operating system provides control over the physical computer, system management, and a basic working environment. It is also called system software. A computer cannot be used without an operating system. Representative operating systems include Microsoft Windows, Solaris, HP-UX, OS/2, and Linux.

The software we create runs on top of an operating system. An operating system is also a program and can be created independently, but doing so requires substantial development experience and advanced knowledge of computer science and systems. Application software runs on an operating system, so application developers generally need less hardware knowledge. They can build the programs they want efficiently by using the features provided by the operating system.

Business applications, games, and even viruses are all application software that run on top of some form of system software.

This book frequently uses the word “system.” It is not simply an abbreviation for operating system. It means the entire information-processing environment composed of hardware and software. For example, C may be used to generate data that acts like an intermediate language for large applications that operate in a manner similar to an operating system. Because the target of a C program is not necessarily an operating system, this book often uses the more abstract term “system.”

C Language | Computer System Development | Hardware Configuration

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article introduces the standard hardware components of a computer and their relationships.

Computer Structure

If you already understand computers through experience with another programming language or assembling computers, you can skip to the article about development environments and compilers.

C is a high-level language, but it is also close to low-level languages. Using C effectively therefore requires some knowledge of computers. This section explains the basics of computer systems.

A computer receives data, calculates with it, and outputs the result. The five basic components required for this process are input devices, output devices, arithmetic devices, control devices, and storage devices.

Table 1. Five Basic Computer Components

Component	Description
Input device	Sends data to a computer
Output device	Outputs calculated results
Arithmetic device	Calculates data according to a program
Control device	Controls the operation of other devices
Storage device	Stores data

Figure 1. Relationships Between the Five Components

Input devices include keyboards, pointing devices such as mice, pens, and touch screens, scanners, optical mark readers, and timers. Displays are representative output devices, but printers and plotters are also output devices.

The arithmetic device and control device form the central processing unit, or CPU. The CPU manages input and output and controls the computer as a whole.

A storage device stores data and calculation results. Important storage directly connected to the CPU is called main memory. Programs use main memory to store data and results. Other storage devices, such as hard drives and ROM, are called secondary storage. Main memory loses its data when power is removed but provides fast access. Secondary storage retains data without power but is slower.

Storage devices hold binary data. A single binary digit is a bit, but CPUs generally process larger units. The smallest processing unit is called a byte, and a byte is commonly eight bits.

Strictly speaking, a byte is not always eight bits. Its size depends on the computer architecture. The term octet explicitly means eight bits and is common in networking contexts. This book generally treats one byte as eight bits.

Storage devices assign an address to each byte. This number is called a memory address. Programs use memory addresses to access information. Memory addresses are central to pointers in C. Remember that every piece of data processed by a computer must have an address that identifies its location.

C Language | Introduction to C

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

C Language | Introduction to C | Development Environments and Compilers

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article introduces the tools and development environment required for programming in C.

Tools Required for Programming

Every task requires the right tools. Drawing a comic requires paper, ink, pens, rulers, pencils, erasers, and screen tones. Performing music requires not only an instrument but also sheet music, a music stand, a tuner, and a metronome. Programming is no different. A computer alone is not enough. Producing high-quality programs efficiently requires an advanced development environment. A development environment consists of programs used to create other programs, including a debugger for finding errors, an editor for writing code, and CASE tools for automating development processes. These development tools are also programs, so it is possible to create them yourself. However, this article focuses on the basic tools needed for C development.

C development involves translating a source program into an object program and then organizing it into an executable format. Converting a source program into an object program is called compilation, and the software that performs this conversion is called a compiler. To run source code written in C, you need a compiler. The usual development process is to write a source program in a text editor and convert it into an object program with a compiler. Finally, a linker combines the required object programs to create an executable file. In most cases, the compiler includes the linker and other tools required to produce executables.

Figure 1. Program Creation Flow

There are various ways to obtain a compiler. A Windows user who is new to computers may prefer an integrated development environment such as Microsoft Visual C++. An integrated development environment provides an editor, compiler, documentation, and tools for developing graphical software. It lets you compile, link, and run a C program with the click of a button, making it approachable for beginners and suitable for serious development.

Free compilers are also available online. One example is Borland C++ Compiler, formerly provided by Embarcadero. It was released for personal development and learning without a warranty. However, because it is not an integrated development environment, it must be used from the command line.

The way you compile and run a C program written in a text editor depends on the compiler. C source files generally use the .C extension. C++ source files use the .CPP extension.

Microsoft Visual C++ and Borland C++ Compiler are C++ compilers, but C++ is compatible with C, so you can compile C programs with a C++ compiler. To compile a program as C, use the .C extension. If you use .CPP, the compiler treats the source as C++, which may produce errors. Some compilers may let you choose the language with an option regardless of the extension. Refer to your compiler documentation for details.

C Language | Introduction to C | Comments

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

Comments let you leave notes in source code. They are ignored during compilation and do not affect the program.

Notes for Future Readers

The C sample programs in this book are only a few dozen lines long at most. The source code is kept as simple as possible and excludes unnecessary details so readers can focus on the essential principles covered in each chapter.

Real-world code, however, contains at least thousands of lines. Large development projects may contain hundreds of thousands or millions of lines. Code at that scale is difficult even for its developers to manage. You may need to read code written by someone else, and even your own code may become difficult to understand when you return to it later.

For this reason, source code can contain comments that have no effect on program execution. A C comment begins with /* and ends with */. Every character between /* and */ is removed during compilation. Because a comment may include newline characters, it can span multiple lines. Comments help explain the source code to other readers and remind you what your own code means when you revisit it later.

Code 1

#include <stdio.h>

int main()
{
    /* This comment does not affect the program. */
    printf("This statement is executed.\n");
    /* printf("This statement is not executed because it is inside a comment.\n"); */
    /*
    Add supplementary explanations that make the source code easier to understand.
    A comment may span multiple lines.
    */
    return 0;
}

This program contains comments in its source code. Leaving explanatory comments is useful in large development projects. Note, however, that comments cannot be written inside string literals.

Comments also cannot be nested. For example, if you write /* /* */ */, only /* /* */ is interpreted as a comment.

Although not defined in the original C specification, many compilers also support single-line comments. A single-line comment starts with two consecutive slash characters, //, and continues to the end of the line.

// This is a comment.
// Its scope is one line, so each line needs its own marker.
printf("Kitty on your lap"); // A comment can also appear after code.
/////////// This is also a comment. ///////////

Single-line comments are part of the C++ language specification rather than the original C specification. However, many modern compilers support C++, so they also permit single-line comments in C code. For example, you can use one to temporarily disable a line while testing a program. If you need to write strictly portable code for an older C standard, avoid this comment style.

The C comment form /* */ and the // form added by C++ are common across many programming languages. They are used in C/C++, Java, C#, JavaScript, and other languages.

C Language | Introduction to C | Data Input with scanf()

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains how to receive values entered from a keyboard with scanf().

Receiving User Input

The programs so far have assigned constants to variables. In real programs, variables are useful for values that change dynamically while the program runs.

How can a program receive dynamic values? Reading data from a disk file is one option. For example, text loaded from a file and displayed on the screen changes at runtime. Reading files is an intermediate topic, so it is explained later.

A simpler option is keyboard input. It makes programs more useful and easier to test. Use scanf() to receive keyboard input. scanf() is an input counterpart to printf() and stores keyboard input in specified variables.

scanf() Function

int scanf("format" , &variableName);

The first argument is a format string. The remaining arguments specify variables that receive input values. Format specifiers are similar to those used by printf(): use %d for an integer and %c for a character. Place & before the variable name.

The & is required because the function needs the address of the variable. Pointers explain this in detail. For now, remember to place & before a variable passed to scanf().

scanf() returns the number of fields successfully converted and assigned.

Code 1

#include <stdio.h>

int main() {
 int iVar = 0;

 printf("정수를 입력해 주세요. > ");
  scanf("%d" , &iVar);

  printf("입력한 수는 %d입니다.\n" , iVar);
  return 0;
}

When Code 1 runs, it requests a value. If you enter an integer, the value is assigned to iVar and displayed. If the input cannot be converted correctly, no value is assigned.

Production programs rarely use scanf() for complex input because robust error handling is difficult. They often read text with another standard-input function, inspect the string, and convert it appropriately. This book uses scanf() to keep introductory examples simple.

C Language

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This beginner’s guide explains the C programming language, which has been used since the 1970s and is still adopted by many software developers and educational institutions.

The explanations and example code are based on ANSI X3.159-1989, American National Standard for Information Systems - Programming Language - C.

C Language | Flow Control

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

C Language | Flow Control | do-while Statement

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains the do statement, which checks whether to repeat a statement after executing it. Unlike a while statement, a do statement always executes its body at least once regardless of the condition.

Looping with a Delayed Condition Check

A while statement evaluates its condition before executing the repeated statement and decides whether to continue the loop. In contrast, a do statement evaluates its condition after executing the statement.

do Statement

do statement while (condition);

Except for executing the repeated statement first, a do statement is basically the same as a while statement. Because a while statement evaluates the condition before running the loop, it skips the body entirely if the first evaluation is false. A do statement is useful when the body must run at least once regardless of the condition.

Code 1

#include <stdio.h>

int main()
{
  int iCount = 1 , iMax;
  printf("반복 횟수를 입력하십시오. >");
 scanf("%d" , &iMax);

  do {
    printf("%d번째 루프입니다.\n" , iCount++);
  } while (iCount <= iMax);
 return 0;
}

Code 1 reads a repetition count and repeats the statement with a do loop. The major difference from a while statement is that the body executes once even if iCount <= iMax is false. Even if the input value is negative or 0, the do statement executes its body once because it checks the condition afterward.

Outside of special cases, do statements are not used often. However, you may encounter one when reading code written by someone else, and some algorithms can be expressed more clearly with a do statement. It is worth remembering.

C Language | Flow Control | Conditional Operator

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains the conditional operator, which selects an expression according to a condition. Unlike an if statement, the conditional operator chooses one of two expressions.

Ternary Operator

Most C operators are unary operators with one operand or binary operators with two operands. The conditional operator ? : is a ternary operator with three operands.

The conditional operator expresses behavior similar to an if statement in a single expression. It is suitable for small branches. For example, if n is not 0, assign x to z; otherwise, assign y.

Conditional Operator

condition ? expression1 : expression2

If the condition is true, the operator selects expression1 and returns its value. Otherwise, it selects expression2. To choose a value to assign to z, write:

z = n ? x : y;

If n is true, this expression assigns x to z. Otherwise, it assigns y. You can write the same logic with an if-else statement, but the conditional operator is more concise.

Code 1

#include <stdio.h>

int main() {
  int iVariable;
  printf("Please input a number 0 or some else>");
  scanf("%d" , &iVariable);
 printf("An input value is %s.\n" , iVariable ? "True" : "False");
  return 0;
}

This program receives 0 or another value from the user and displays whether it is true or false. The expression iVariable ? "True" : "False" returns "True" if iVariable is true and "False" otherwise. The %s conversion specifier in printf() displays the selected string.

C Language | Functions

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

A function implements a specific feature as a separate unit. It is an important concept in structured programming. This section explains how to write and call functions.

C Language | Arrays

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

An array is a data structure made up of indices and the data corresponding to those indices. This section explains how to declare and use arrays.

C Language | Pointers

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

Pointers are one of the most powerful features of C and one of the most difficult concepts for learners. This section explains them step by step, starting with the basics.

C Language | Pointers | String Pointers

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains character arrays and pointers to strings. Do not modify a string literal through a pointer. To edit a string based on a literal, copy it into an array.

Pointers to String Literals

Initializing an array with a string literal stores the string in the array. What happens when a string literal appears in an expression other than an initializer? A string literal evaluates to a pointer to the string.

For example, printf("Kitty on your lap") passes a value of type char * to printf(). Where is that string stored?

Constants such as string literals and numbers are converted into binary data at compile time and stored in the executable file. When the program runs, the data is loaded into memory as constant values. The specific storage and loading behavior depends on the compiler and system.

Because a string literal is already stored in memory while a program runs, copying it into another array is useful only when character-level editing is needed. Choose between a pointer to the literal and a copied array according to your purpose.

char chStr[] = "Kitty on your lap";

This statement copies the literal into a new array named chStr. It is appropriate when you need to edit the resulting array. If you only need a variable that points to the string, copying is unnecessary.

char *chpStr = "Kitty on your lap";

This differs significantly from array initialization. chStr[] = "..." allocates an array large enough to store the string and copies the literal into it. In contrast, *chpStr = "Kitty on your lap" assigns the address of a string literal loaded from the executable.

Code 1

#include <stdio.h>

int main() {
 char *chpStr = "Kitty on your lap";
 printf("%s\n" , chpStr);
 return 0;
}

Code 1 assigns the address of the literal "Kitty on your lap" to chpStr and displays the string. Do not modify a string literal through this pointer. Attempting to do so results in undefined behavior.

C Language | Pointers | Arrays of Pointers

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains how to create an array whose elements are pointers. Arrays of pointers help manage large amounts of data in a structured way.

Creating an Array of Pointers

A pointer is a type of variable that stores a memory address. Like ordinary integer variables, pointers can be stored in arrays. Except that each element is a pointer, an array of pointers works like an ordinary array. The same principles apply to one-dimensional and multidimensional arrays.

Declare an array of pointers as follows.

Declaring an Array of Pointers

type *pointerVariableName[];

This syntax lets you manage multiple pointers as an array. Specify an index to retrieve a stored address or access the content at that address. If you understand arrays and pointers, an array of pointer variables is straightforward to use.

For example, when managing multiple strings like an array, an array of pointers to strings is often more natural than a multidimensional array.

Code 1

#include <stdio.h>

int main() {
 char *chStr[] = {
   "Blue Blue Glass Moon" ,
    "Under The Crimson Air"
 };

  printf("%s\n%s\n" , *chStr , *(chStr + 1));
 return 0;
}

The chStr array in Code 1 has two elements that store pointers to strings. The elements do not contain the strings themselves. They store only pointers to the strings. Compared with a string table implemented as a two-dimensional array, this representation is flexible because you can update the table simply by changing the referenced addresses.

C Language | Pointers | Generic Pointers

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article introduces void pointers, which can store pointers of any type. They are useful when passing pointers through functions without depending on a specific type.

Generic Types

Sometimes a function should receive a pointer without restricting its type. For example, a function may receive or return different pointer types depending on the situation.

Consider a function that initializes a memory range with a specified value regardless of type. Accepting char * would work, but callers with other pointer types would need casts.

The initialization operation does not depend on the data type. A generic pointer is appropriate. A void pointer can receive any pointer type and can be converted back with a cast.

Declaring a void Pointer

void * variableName

A void pointer can receive a pointer of any type. This makes it possible to write a simple function that receives pointers without depending on their types.

Code 1

#include <stdio.h>

void FillMemory(void *mem , int size , char n) {
 int iCount;
 for(iCount = 0 ; iCount < size ; iCount++)
    *((char *)mem + iCount) = n;
}

int main() {
 unsigned int iCount , iArray[8];
  FillMemory(iArray , 4 * 8 ,0xFF);

 for(iCount = 0 ; iCount < 8 ; iCount++)
   printf("iArray[%d] = %X\n" , iCount , iArray[iCount]);

 return 0;
}

FillMemory() receives a pointer to a memory region, its size, and an initialization value. The example creates an eight-element int array and initializes its 32 bytes to 0xFF, assuming four-byte integers.

Functions that receive raw memory addresses regardless of type are common. void pointers support abstractions required by extensible systems.

C Language | Pointers | Parameters of the main() Function

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains how to retrieve strings passed by a parent process or command when a program starts.

Command-Line Arguments

The main() function can receive arguments. Where do they come from? When a parent process starts a program, it can pass options as strings. These values are generally provided from the command line. They let you provide information required to run the program.

The main() function receives two arguments. One is the number of command-line arguments. The other is an array of the strings passed as command-line arguments. By convention, the first parameter is named argc and the second is named argv. The value of argc is the argument count, and argv contains the argument strings. In addition to the form without arguments used so far, a typical main() function can use the following form.

main() Function

int main(int argc , char *argv[])

Use this form when processing command-line arguments. The parameter names are optional, but conventionally argc abbreviates argument count and argv abbreviates argument vector. Access the argv array to retrieve the command string at a given index.

Code 1

#include<stdio.h>

int main(int argc , char *argv[]) {
  int iCount;
 for(iCount = 0 ; iCount < argc ; iCount++)
    printf("%d번째 인수 = %s\n" , iCount + 1 , argv[iCount]);
  return 0;
}

Code 1 displays the arguments passed to main(). The value of argv[0] is the name of the executed program. If argc is greater than 1, command-line arguments were provided.

Command-line arguments are stored as a table of strings. Check argc and access the appropriate argv element to retrieve an argument. The first actual argument is argv[1], and the last is argv[argc - 1]. The standard also guarantees that argv[argc] is NULL.

C Language | Structure Declarations

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This section explains structures.

C Language | Structure Declarations | Automatic Variables - auto

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

The auto keyword explicitly declares a variable as an automatic variable valid only within the block where it is declared. Variables declared inside blocks are automatic by default, so using auto has little practical meaning in modern C.

Variables with Local Lifetimes

C variable declarations can use storage-class specifiers to define variable lifetimes explicitly. typedef is technically a storage-class specifier, although it is unusual. Ordinary storage classes determine when variables are released from memory.

Storage-Class Specifier

storage-class-specifier type variable ...

You cannot combine multiple storage-class specifiers in one declaration.

A variable declared inside a block, such as a function body, is an automatic variable. It is valid only within that block. It is initialized when control enters the block and released when control leaves it. The compiler automatically treats variables declared inside blocks as automatic variables.

You can explicitly declare an automatic variable with auto. Because this provides no practical advantage, it is generally omitted.

auto Storage-Class Specifier

auto type variableName ...

The meaning of auto differs between C and C++. In C++11, auto indicates type inference. Compiling C code that uses the C meaning of auto as C++ may therefore cause an error.

Code 1

#include <stdio.h>

int main() {
 auto char *str = "Kitty on your lap";
 printf("%s\n" , str);
  return 0;
}

The str variable in Code 1 explicitly uses the auto storage-class specifier. Omitting auto makes no difference. Variables declared inside functions are automatic by default.

C Language | Structure Declarations | Register Variables - register

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

Ordinary variables are stored in main memory. A variable declared with register may be placed in a fast CPU register. The compiler decides whether to use a register in practice.

Storing Values in Registers

Some local variables are accessed frequently. For example, a loop that processes graphics may repeatedly use variables involved in pixel conversion. It is reasonable to store frequently accessed values in faster memory.

C lets you declare such a variable as a register variable. Registers are fast storage locations inside the CPU.

Ordinary variables are stored in main memory. Registers can be faster because the CPU does not need to transfer values from main memory before processing them.

register Specifier

register type variableName ...

Register count and size depend on the physical computer. A compiler may ignore a register declaration and handle the variable normally if storing it in a register is not appropriate.

Because register variables are not necessarily stored in main memory, you cannot request their addresses.

Code 1

#include <stdio.h>

int main() {
 register int i;
 register int k;

 i = 5;
  k = i * 3;

  printf("i = %d, k = %d\n" , i, k);
 return 0;
}

This code declares i and k as register variables. Whether they are actually stored in registers depends on the compiler.

Modern compilers optimize code effectively, so developers rarely need to use the register specifier today.

C Language | Structure Declarations | Static Variables - static

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

Ordinary local variables lose their values when a function finishes. A static variable declared with static has a permanent lifetime. It is visible only inside its function but retains its value until the application exits, like a global variable.

Persistent Local Variables

Variables declared inside a function normally have local lifetimes. They are initialized when the function runs and released when the function returns. This is suitable for temporary storage used during calculations.

Sometimes a program needs longer-lived state. For example, how can a function track how many times it has been called? Incrementing a dedicated counter inside the function is reliable, but an automatic variable loses its value whenever the function returns.

A global counter would retain its value, but another function could accidentally change it. A static variable solves this problem. It retains its value until the program exits but remains inaccessible to other functions.

static Specifier

static type variableName ...

A variable declared this way has a global lifetime. If declared inside a function, it is not destroyed when the function returns.

Code 1

#include <stdio.h>

void ShowCount(void) {
 static int iCount = 0;
  printf("iCount = %d\n" , iCount++);
}

int main() {
 ShowCount();
  ShowCount();
  ShowCount();
  return 0;
}

The ShowCount() function displays how many times it has been called. The static variable iCount is initialized only once and increments across calls.

Static variables can also reduce initialization overhead for values that remain constant, such as character arrays containing fixed strings.

C Language | Structure Declarations | Storage Classes for Functions

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

Function declarations can use the extern and static specifiers to define storage classes. To hide a function so that other source files cannot call it, declare the function with static.

Function Visibility

Unlike variables, functions do not have an inner scope level. A function has global duration and can be referenced anywhere in the same file. As explained in the article about function declarations, a prototype declaration is required before calling a function.

When compiling multiple files together, function names can conflict just like variable names. Functions therefore also have storage classes. A function can use either static or extern.

A function with the static storage class can be called only from the file where it is defined. Functions in other files cannot call it. In contrast, an extern function can be called from other files. If you omit the storage class, extern is implied.

Code 1

#include <stdio.h>

void Function1(void);
void Function2(void);

int main() {
 /*Function1();  /*error*/
 Function2();
  return 0;
}

Code 2

static void Function1() {}
extern void Function2() {}

If you compile Code 1 and Code 2 together, main() can call Function2() but cannot call Function1() because it is not visible from Code 1. Uncommenting the Function1() call causes an error. The static storage class hides Function1() from external files.

This is useful for a function specialized for a particular process in one file. Assign the static storage class to a function with low independence to avoid name conflicts.

C Language | Preprocessing

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

Preprocessor directives specify how to process source code before compilation.

C Language | Preprocessing | Include - #include

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

The #include preprocessor directive, which is processed before compilation, can include header files containing declarations and other shared definitions in every source file. This operation is called an include.

Creating a Header File

In medium-sized and larger development projects consisting of multiple files, file organization is as important as programming techniques. A small test program like the ones used here can fit in a single file, but real projects cannot. Development teams often work concurrently on separate areas, such as graphics and audio, which cannot reasonably be managed in one file.

When logically separated features are developed in separate files, those files must eventually be brought together for compilation. By convention, the source file containing the main() function and used to create an executable has a *.c extension. Other files that provide library declarations and feature sets are header files with a *.h extension. Header files are inserted before the main() function.

To compile multiple files together, use the #include preprocessor directive to tell the compiler to insert a header file at a specified location. When the compiler encounters #include, it inserts the specified file at that point. Until now, examples such as #include <stdio.h> have included library files provided with C. This operation is called including a file.

For files other than standard headers, write the filename inside double quotation marks, as in #include "filename". This was explained in Your First C Program. Consult your compiler documentation for details about how files are searched. A filename enclosed in double quotation marks is usually searched for in the same directory as the *.c file.

An include can be understood as a simple file insertion. Commands beginning with # are instructions for the preprocessor, not the compiler. Preprocessing runs before source code is compiled. Because #include inserts a file, the contents of the specified file are inserted as-is before the compiler processes the source code. Developers can place declarations for common functions in a header file and include it in the project’s C source files. This avoids writing the same declarations repeatedly.

Code 1

/* sample.h */
int strlen(const char *str);

Code 2

int strlen(const char *str) {
  int count;
  for(count = 0 ; *(str + count) ; count++);
  return count;
}

Code 3

#include <stdio.h>
#include "sample.h"

int main() {
 char *str = "Kitty on your lap";
  printf("%s length=%d\n" , str , strlen(str));
  return 0;
}

Create the header file shown in Code 1, include it in Code 3, and compile the program. The contents of the header file are copied to the location of #include "sample.h" before compilation. Code 1 declares the strlen() function, which returns the number of characters in a string excluding the null character. The implementation of strlen() is written in Code 2. Once created, a header file like this can be reused across development projects.

C Language | Preprocessing | Stringification

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains how to convert code passed to a function-like macro into a string. It lets you pass non-string text to a macro and convert it into a string during expansion.

Function-Like Macros and the Stringification Operator

A preprocessing operator available in function-like macros converts a sequence of tokens received as a parameter into a string. It analyzes the tokens and expands them with quotation marks. This makes it possible to create macros that automatically convert numbers and token sequences into strings.

To stringify a token sequence, place the # operator before a macro parameter.

#define TOSTRING(param) #param

Because this is a macro, the token sequence passed to param is not restricted. The # operator stringifies any token sequence.

TOSTRING(1234) → "1234"

TOSTRING(int iValue = 10\n) → "int iValue = 10\\n"

TOSTRING("Kitty") → "\"Kitty\""

This conversion occurs at the source-text level before compilation, not dynamically while the program runs. The stringification operator converts quotation marks into \" and backslashes into \\, preserving the original tokens in string form.

Code 1

#include <stdio.h>
#define PRINTLN(string) printf(#string "\n")

int main() {
  PRINTLN(0xFF);
  PRINTLN(Kitty on your lap);
 PRINTLN(Kernighan and Ritchie wrote "hello, world\n" on their book.);
  return 0;
}

The PRINTLN() macro in Code 1 stringifies its argument and displays it with printf(). The last example includes the token "hello, world\n", which the preprocessor converts to \"hello, world\\n\". The quotation marks and escape sequence are therefore displayed literally.

C Language | Preprocessing | Token Pasting ##

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

This article explains the ## operator, which combines arbitrary tokens. It is mainly used to join a parameter passed to a macro with another macro or value.

Token-Pasting Operator

In addition to the stringification operator, macros defined with #define support another important preprocessing operator: ##, the token-pasting operator. It can be used in ordinary and function-like macros.

`##` Operator

token1 ## token2

The token-pasting operator joins the token on its left with the token on its right. This happens at the source level during preprocessing, not dynamically while the program runs. For example, WIN ## 32 becomes WIN32, and WIN ## 16 becomes WIN16.

#define INT16 short
#define INT32 int
#define INT(n) INT ## n

The INT() macro joins the token INT with the parameter n. For example, INT(16) expands to INT16, which then expands to short.

Code

#include <stdio.h>
#define TOKEN0 "Kitty"
#define TOKEN1 "Kitten"
#define TOKEN(n) TOKEN ## n

int main() {
  printf("%s\n" , TOKEN(0));
 printf("%s\n" , TOKEN(1));
 return 0;
}

The TOKEN() macro receives a token suffix. For example, TOKEN(0) joins TOKEN and 0, producing TOKEN0. Because TOKEN0 is defined with #define, it expands to "Kitty".

A new token created with ## must be valid. An invalid token causes a compile error. Remember that token pasting is source-level expansion performed before compilation.

C Language | Advanced Features

kc@example.com (kc kim) — Sun, 22 Oct 2017 15:52:10 +0900

devkuma – C

C Language | Computer System Development

C Language | Computer System Development | Program Structure

Software and Programming

C Language | Computer System Development | Hardware Configuration

Computer Structure

Table 1. Five Basic Computer Components

Figure 1. Relationships Between the Five Components

C Language | Introduction to C

C Language | Introduction to C | Development Environments and Compilers

Tools Required for Programming

Figure 1. Program Creation Flow

C Language | Introduction to C | Comments

Notes for Future Readers

C Language | Introduction to C | Data Input with scanf()

Receiving User Input

scanf() Function

C Language

C Language | Flow Control

C Language | Flow Control | do-while Statement

Looping with a Delayed Condition Check

do Statement

C Language | Flow Control | Conditional Operator

Ternary Operator

Conditional Operator

C Language | Functions

C Language | Arrays

C Language | Pointers

C Language | Pointers | String Pointers

Pointers to String Literals

C Language | Pointers | Arrays of Pointers

Creating an Array of Pointers

Declaring an Array of Pointers

C Language | Pointers | Generic Pointers

Generic Types

Declaring a void Pointer

C Language | Pointers | Parameters of the main() Function

Command-Line Arguments

main() Function

C Language | Structure Declarations

C Language | Structure Declarations | Automatic Variables - auto

Variables with Local Lifetimes

Storage-Class Specifier

auto Storage-Class Specifier

C Language | Structure Declarations | Register Variables - register

Storing Values in Registers

register Specifier

C Language | Structure Declarations | Static Variables - static

Persistent Local Variables

static Specifier

C Language | Structure Declarations | Storage Classes for Functions

Function Visibility

C Language | Preprocessing

C Language | Preprocessing | Include - #include

Creating a Header File

C Language | Preprocessing | Stringification

Function-Like Macros and the Stringification Operator

C Language | Preprocessing | Token Pasting ##

Token-Pasting Operator

## Operator

Code

C Language | Advanced Features

`##` Operator