Virtually all structured programs, including C programming,
share a similar overall structure. In this comprehensive guide, we will explore
the key components of a C program's structure. By the end of this post, you
will have a solid grasp of how to structure your C programs effectively.
Statements to Establish the Start of the C Program
Every C program begins with a set of statements to set the
stage for the code that follows. These statements include:
Include Directives
In C, the #include directives are used to start the
program. These directives are also known as preprocessor headers. They allow
you to include external files, such as header files, which contain function
declarations and macros to be used throughout the program.
#include <stdio.h> // An example of an include directive
Main Function Declaration
The main function is the entry point of a C program.
It is the starting point for the program's execution. The main function is
declared with the following syntax:
int main() {
// Code goes here
return 0; // Return statement indicating successful execution
}
The open curly bracket { marks the beginning of your
program, where you'll write your code.
Variable Declarations and Constants
Variables: Locations in Memory
In C programming, variables are locations in memory where
values are stored for use by a program. Variables are declared with both a
variable name and a data type. For example:
int integer1;
int integer2;
int sum;
These definitions specify that integer1, integer2,
and sum are of type int.
Rules for Variable Names
Variable names in C follow specific rules:
- Use
only alphabet letters, digits, and underscores in variable names.
- The
first character in a variable name must be an alphabet letter or
underscore.
- No
commas or blanks are allowed within a variable name.
- No
special symbols other than underscore are allowed in variable names.
- C
keywords like int, float, struct, if, and while
cannot be used as variable names.
- Every
variable name should always appear on the left-hand side of the assignment
operator.
Variable Declaration
Before using a variable in C, it must be declared,
specifying what kind of information will be stored in it. This process is
called defining a variable. Variables must be declared at the start of any block
of code, and most are found at the start of each function.
int integer1, integer2, sum; // Declare multiple variables of the same type on the same line
Types of Variables in C
There are different types of variables in C:
- Local
Variable: Declared within the body of a function and can
only be used within that function.
- Static
Variable: Another type of local variable, specified using
the static keyword in the variable declaration. A static variable
is not destroyed on exit from the function.
- Global
Variable: Located outside of any of the program's functions,
making it accessible to all functions.
Let's explore some examples of variables in C:
#include <stdio.h>
int main() {
// Integer variable
int i = 20;
printf("This is my integer: %d\n", i);
// Calculate the sum of two numbers
int number1 = 4, number2 = 19, sum;
sum = number1 + number2;
printf("The sum of two numbers is %d\n", sum);
// Character variable
char c;
c = 'd';
printf("This is my character: %c\n", c);
return 0;
}
In this example, we use int for integers, char
for characters, and we perform calculations with variables.
Constants Declaration
In C, a constant is a literal number, single character, or
string of characters that cannot be modified once defined. Constants are used
to prevent unintended modifications, as the compiler will catch attempts to
reassign new values to constants. There are two ways to define constants in C.
Using #define Statements
The #define preprocessor directive is used to define
constants. For example:
#define TRUE 1
#define FALSE 0
#define PI 3.1415
Wherever the constant appears in the program, the
preprocessor replaces it with its value.
Using the const Keyword
The const keyword can be used in conjunction with a
variable declaration to define a constant. For example:
const float PI = 3.1415;
If the compiler encounters an attempt to assign a new value
to a const-declared variable, it will throw an error.
Here's an example using constants:
#include <stdio.h>
#define PI 3.1415
int main() {
float area, radius = 4;
area = PI * radius * radius;
printf("The area of a circle is %f\n", area);
return 0;
}
In this program, we calculate the area of a circle using the
constant PI.
Format Specifiers
C provides various format specifiers to work with different
data types. Format specifiers are used to define the type of data to be printed
on standard output. They are essential for both formatted input and output.
Here are some commonly used format specifiers in C:
- %c:
Character
- %d:
Signed integer (short, unsigned short, int, long)
- %f:
Floating point (float, double)
- %s:
String
Reading Input of Variables
Reading input in C is typically done using the scanf
function. Let's take a look at a program that reads and calculates the sum of
two numbers using scanf:
#include <stdio.h>
int main() {
int number1, number2, sum;
printf("Enter the first number: ");
scanf("%d", &number1);
printf("Enter the second number: ");
scanf("%d", &number2);
sum = number1 + number2;
printf("The sum of two numbers is %d\n", sum);
return 0;
}
In this example, we use %d as the format specifier
for integers and the & operator to store values that the user
inputs.
This program prompts the user to enter two numbers,
calculates their sum, and displays the result.
Mastering the structure of a C program is essential for
writing effective and error-free code. Understanding the inclusion of header
files, variable declarations, constants, and format specifiers is the
foundation of successful C programming. With the knowledge and examples
provided in this post, you are well-equipped to structure your C programs
effectively and work with variables and constants like a pro.
