Structure of C++ Programs Explained With Examples

16 mins read

C++ is one of the most popular and widely used programming languages in the world. It is used in the development of a wide range of applications, including games, operating systems, web browsers, and many others. To write a C++ program, one must understand the various aspects and components of the language. In this blog, we will discuss the basic structure of C++ programs, the different sections and components of a C++ program, and how to compile and execute a C++ program.

Structure Of C++ Program: Components

The structure of C++ program typically consists of one or more source code files that together define the different components of the program, such as main function, member functions, class definition, headers/ standard headers, comments, variables, data types, namespaces, input/ output statements, etc. In the section below we have explained the most important segments that form the basic structure for a C++ program, with examples.

Documentation Section In Structure Of C++ Program

The documentation section of a C++ program serves as an important tool for developers to explain the logic, purpose, and structure of the code. Although this section is optional, it is highly recommended to include it, especially in larger programs where understanding the intent behind the code is crucial.

This section typically consists of comments that describe:

• Program Overview: A brief description of what the program does and its main features.
• Logic Explanation: An outline of the program's logic, including key algorithms or processes used.
• Author Information: Details about the author(s), including names and contact information, if necessary.
• Date of Creation: The date when the program was written or last modified.
• Usage Instructions: Any specific instructions on how to compile and run the program.

Example of a documentation section using multiline comments:

/* Program: This is a blog on the structure of C++ program
Author: Shivani Goyal
Description: Here, we will explain the different components of a C++ program with the help of example */

Preprocessor Section In Structure Of C++ Program

Preprocessor directives are invoked to perform various pre-processing tasks, such as importing header files, declaring namespaces, defining constants, and other such operations that need to be done before the program starts executing.

• Header files usually contain function prototypes/ in-built functions, class definitions, macro definitions, and other declarations essential for the program to use a particular library or API.
• When including libraries, we must use the #include directive followed by the name of the header file. 
• Preprocessor directives are also used to define macros and constants. Macros are defined using the #define directive, allowing values to be replaced by their names when macros are expanded.

For example:

#include <iostream> //importing header iostream to handle input/ output operations
using namespace std; //importing std namespace
#define PI 3.14159 //Defining a constant PI whose value is 3.14159
#define SQUARE(x) ((x) * (x)) // Define a macro for calculating the square of a number

Here, we include the <iostream> header file, which provides access to the input/ output operations (such as cout and cin).

• Then we use the #define directive to define a constant named PI whose value cannot be changes across the program and a macro SQUARE which calculates the square of the argument x.
• We can access the constant by its name anywhere in the program. And for the macro, whenever we use the name SQUARE, the definition will be inserted inline.

We will discuss the namespace inclusion in the next section.

Namespace Declaration In Structure Of C++ Program

Namespace declarations define named scopes that help organize and group related code. They group a set of identifiers under a common name, avoiding naming conflicts and improving readability. Namespaces are part of the C++ code processed during the compilation phase and help manage code across different parts of a program or across multiple libraries without conflicts. In other words, it helps avoid possible compile-time errors that might arise due to identical-name conflicts.

The standard namespace, std, contains common C++ libraries, including those for I/O operations, strings, and containers. Adding the line –using namespace std;– at the beginning of the program brings all standard library names into the global scope, allowing us to use cout instead of std::cout, for example.

Syntax:

usingnamespace std;

Note: Together, the preprocessor and the namespace declaration for the linking section of the structure of C++ program. It comprises the tasks to be performed by the compiler so that the headers and other code segments are ready before execution.

Global Variables In Structure Of C++ Program

As mentioned in the preprocessor directive section, we use the

Global variables are declared outside any function, class or block of code, making them accessible from any part of the program.

• While required in some cases, it is generally considered good practice to minimize the use of global variables.
• This is because a program structure with variables (global) is harder to read, understand and debug. So use them judiciously and only when necessary.

Code Example:

#include<iostream>
using namespace std;

int global = 10;

int main(){
cout<<"The value of the global variable is:"<<global;
}

Output:

The value of the global variable is:10

In this simple C++ program example, we include the header file and use the namespace. Then, we declare a global variable named global outside of the main() function. We then access it from inside main and print its value to the console using cout.

Functions Declarations In Structure Of C++ Program

Functions are used to encapsulate code statements or blocks of code. They group a set of instructions that perform a specific task, which can then be executed simply by calling the function.

• By using the function name, we can call or invoke these functions from other parts of the program, making it easier to reuse code, implement modularity, and improve the readability of the program.
• In the structure of a C++ program, function declarations are made outside of any other block, typically before the main() function.
• Function definitions can be provided alongside the declaration or after the main() block.
• A coder can either use any of the many built-in functions already available or create specific user-defined functions as deemed fit.

Here is an example that showcases how functions work:

Code Example:

#include <iostream>
using namespace std;

// Function that adds two numbers and prints the sum
void add_two_numbers(int x, int y) {
cout << x + y;
}

int main() {

int n = 5, m = 6;
add_two_numbers(n, m); // add_two_numbers function is called from the main function

return 0; // Optional, but good practice to include a return statement
}

Output:

11

Here, we define a function named add_two_numbers() which takes two parameters x and y of integer types. It calculates the sum using addition arithmetic operator and prints the result using cout.

• In the main() function, we initialize two integer variables n and m with values 5 and 6, separated by a comma.
• Then, we call the add_two_numbers() function passing n and m as arguments. As seen in the output, the function prints the sum of the variables.

Check out this amazing course to become the best version of the C++ programmer you can be.

Main Function In Structure Of C++ Program

The main function is the entry point or startup function for every C++ program. Meaning, this section defines the main() function of the program. This is where the program starts executing; hence, this section is a mandatory part of the structure of C++ program.

It includes all necessary components, such as:

• Function Declaration: This specifies the return type, function name, and parameters (if any). Sometimes, we use command-line arguments in the main() function declaration, like main (arg){}.
• Program Execution: The code written inside the main function, which runs when the program is executed. This consists of most variable declarations, function calls, etc.
• Return Statement: This is used to return a value to the operating system upon program completion, indicating whether the program executed successfully or encountered an error.

All in all, the main function coordinates the flow of the entire program by calling other functions, handling user input and output, and performing various tasks, such as initialization of variables and managing the program’s lifecycle.

Code Example:

#include <iostream> //importing header file for input and output streams

int main(){ // Declaration of the main() function
cout<<"Hello, Unstoppable!"; // printing hello world on the screen
}

Output:

Hello, Unstoppable!

In this basic C++ program example, we include the header file and then initiate the main() function.

• When the program is executed, this will be the first function that runs.
• Inside, we use cout to print the string message "Hello, Unstoppable!" to the console.
• Finally, the return 0 statement signifies that the program has been completed successfully.

Variables & Data Types In Structure Of C++ Program

To begin with, a variable is used to store values or data in the code/ structure of C++ program to be used later. As is evident, there are different types of data that can be stored in the program. The C++ language supports various data types, including integers, floating-point numbers, characters, and Boolean values.

Note that each data type has a purpose and each data type has a different range and precision. Therefore, it is important to choose the correct data type and make variable declaration in keeping with our requirement to ensure efficient usage of memory.

Code Example:

#include <iostream>

int main(){

int a=5;// 5 is assigned to the integer variable a
float b=5.768;//5.768 is assigned to the float variable b
char c='A';// character 'A' is assigned to the char variable c
bool d=true;// true is assigned to the Boolean variable d

}

In the C++ code example above, we have declared and initialized four variables: a of type int with 5, b of type float with 5.768, c of type character with 'A', and d of type bool with true. As you can see, we have declared the variables inside the main() function.

Operators In Structure Of C++ Program

Operators are used to perform various operations on data/ values stored in variables in a program. C++ provides support for various types of operators, including arithmetic, assignment, relational comparison, bitwise operators and logical operators.

We can use these operators as needed to meet the requirements of task at hand. In the example C++ program below, we have showcased the use of some arithmetic, locigal/ comparison and bitwise operators.

Code Example:

#include<iostream>
using namespace std;

int main(){

int a=10;// '=' is assignment operator
int b=5;

cout<<a+b<<endl;// '+' is arithmetic addition operator
cout<<a-b<<endl;// '-' is arithmetic subtraction operator
cout<<a*b<<endl;// '*' is arithmetic multiplication operator
cout<<a/b<<endl;// '/' is arithmetic division operator

cout<<(a>b)<<endl;// '>' is comparison operator.
cout<<(a==b)<<endl;// '==' is comparison operator.
cout<<(a<b)<<endl;// '<' is comparison operator.

cout<<(a&b)<<endl;// '&' is bitwise and operator
cout<<(a|b)<<endl;// '|' is bitwise or operator
cout<<(a^b)<<endl;// '^' is bitwise Xor operator

}

Output:

15
5
50
2
1
0
0
0
15
15

Here, inside the main() function, we declared two integer variables a and b and assigned values 10 and 5 to them, respectively. Then, as mentioned in code comments, we used various operators inside cout command to make calculations and print the results.

Level up your coding skills with the 100-Day Coding Sprint at Unstop and claim the bragging rights, now!

Control Structures/ Statements In Structure Of C++ Program

Control structures/ statements are special tools used to control and/or alter the flow of the program. C++ allows for various control structures/ program statements like if-else statements, and switch-case statements, for loops, while loops, do-while loops, etc. Below is an example showcasing implementation of the if-else conditional statement, for loop and a while loop.

Code Example:

#include<iostream>
using namespace std;

int main(){

int k=1;

//if-else statement that prints YES if k is equal to 1, else prints NO
if(k==1){
cout<<"YES";
}else{
cout<<"NO";
}

//for loop to print first 10 natural numbers
for(int i=1;i<=10;i++){
cout<<i<<" ";
}

//while loop to print first 10 natural numbers
while(k<=10){
cout<<k<<" ";
k++;
}
}

Output:

YES
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

Comments In Structure Of C++ Program

Comments are used to provide explanations and documentation for the code and they are not executable statements. Meaning, the compiler ignores the comments and does not execute them. It’s considered good practice to always write comments for your code to improve the readability of the program.

There are two types of comment styles supported in C++ programming, namely- single-line comments and multiline comments. The symbol // is used for single line comments (or single comments) while /* and */ are used for writing multiline comments that span more than one line. Below is a snippet example of comments in C++ programs.

Example:

//this is a single line comment
/*
this
is
a
multiline comment
*/

For more, read: Comment In C++ | Types, Usage, C-Style Comments & More (+Examples)

Classes and Objects In Structure Of C++ Program

Classes and objects are two major components of Object-Oriented Programming (OOP) paradigms in C++. They enable developers to write reusable, readable, and modular code.

• A class is a user-defined data type that contains data members (variables) and member function definitions (functions) that operate on those data members.
• Objects are instances of a class and are used to access the data members and member functions.

In the structure of C++ programs, class definitions are given before the main() function and the objects are generally instantiated inside the main() part.

Code Example:

#include<iostream>
using namespace std;

//defining class and its data members and member functions
class Square {
public:
int side; //Class data member representing the side of a square

//Class member function that calculates the area of square using
data member
int area(){
return side*side;
}

};

int main(){

square s;//creating object
s.side = 5;//assigning the value to data member using object

cout<<"Area of square of side 5 is "<<s.area();//calling member function using object

}

In the example above, we define a class called Square after including the header file and using the namespace. Inside the class, we define a public data member side (of type int) and a member function area(), which uses side to calculate the area.

Then, in the main() function, we create an object of class Square, called s, and initialize its side member with the value 5. Finally, we call the area() member function inside cout to print the area to the console.

Compilation & Execution Of C++ Programs | Step-by-Step Explanation

Compiling and executing a C++ program involves several steps, each crucial to ensuring the smooth and successful execution of the program. They are:

1. Writing the code:

The first step in the execution of a C++ program is to write the code/ lines of code for the specified purpose. This involves utilizing all the components we learned above in a logical manner.

2. Saving the code:

Once the code is written, we have to save the code in a file with a .cpp extension. This is the extension for source code files in C++. This file of source code contains all the code that will be compiled and then executed in the steps ahead.

3. Preprocessing:

Before the code is compiled, it goes through a preprocessor. At this stage, the prerpocessor checks the code for any directives such as #include statements, #define statements, etc., and replaces them with the appropriate code. This ensures that all the necessary libraries and header files are included in the code.

4. Compiling:

During the compilation process, the C++ compiler reads the code within the curly braces and checks for any syntax errors. It then compiles the code into object code (i.e. binary code or machine-readable instructions).

5. Linking:

After the compilation of the code, it needs to be linked to the necessary libraries and header files that we have included in the program. This ensures that the program has access to all the functions and variables defined within it. The linker also checks for any unresolved symbols in object code and links the code to the appropriate libraries.

6. Generating Executable:

After the code is successfully compiled and linked, it is ready to be executed. This file is called an executable file. This file contains all the machine-readable instructions that will be executed by the computer.

7. Execution:

The final step is to execute the program. The executable file is loaded into memory, and the program is executed.

Looking for guidance? Find the perfect mentor from select experienced coding & software experts here.

Structure Of C++ Program With Example

It’s always easier to understand what we learn through examples, so here is a simple sample program that covers all the components of structure of C++ program we've learned in the section above.

Code Example:

/*
This is a sample program.
The purpose is to explain the structure of a C++ program.
We will make use of the various components we learned about in this article.
*/

#include<iostream>// include the input/output library
using namespace std;//use the standard namespace

//Defining a class
class Person{

public:
string name;//data member

//Defininf a member function
string printName(){
return name;}
};

//Defining a function that adds two numbers and returns the sum
int sum(int a,int b){
return a+b;
}

int main(){

//declare and initialize various variables

int x=5,y=10;
float f=3.14;
char c='a';
cout<<"This is a Sample program for your understanding!!"<<endl;//output a message

cout << "This is a Sample program for your understanding!!" << endl; // Outputs a message

// Using an if-else statement to find the larger number
if(x>y){
cout<<"x is greater than y!"<<endl;
}else{
cout<<"x is less than y!"<<endl;
}

//Using a for loop to prin the first 10 natural numbers
for(int i=1;i<=10;i++){
cout<<i<<" ";
}
cout<<endl;

cout<<"x+y="<<sum(x,y)<<endl; //Printing sum of x and y by calling sum function

person p; // Creating an object of class person
p.name = "MyName"; // Assign value to name using the object
cout << p.printName() << endl; // Print the assigned name using the object and member function

}

Output:

This is a Sample program for your understanding!!
x is less than y!
1 2 3 4 5 6 7 8 9 10
x+y=15
MyName

Conclusion

By now, you must agree with the statement that understanding the structure of C++ programs is essential for programmers to write effective and efficient code.

• A C++ program can consist of preprocessor directives, the main function, data types and variables, operators, control structures, comments, functions, classes and objects, etc. Each of these components is crucial in the execution of a program.
• Developers must also understand the various steps involved in the compilation and execution of a C++ program, from writing the code to execute.
• By understanding the structure of C++ programs and their compilation and execution process, developers will be able to create efficient and effective code that meets the requirements of their projects.

Also Read: 51 C++ Interview Questions For Freshers & Experienced (With Answers)

Frequently Asked Questions

Q1. What are the main components of a C++ program?

The main components or structure of C++ program can be split into following sections:

1. Documentation Section: This section is used to document the logic, author details, purpose, and other relevant information about the program.
2. Linking Section: Consists of preprocessor directives and inclusion for libraries and APIs.

• • Preprocessor Directives: The #include and #define directives to include header files (like iostream header) and defining constants or macros, respectively.
  • Namespace inclusion: For example, using namespace std; allows the program to utilize the standard library without prefixing with std::.

3. Definition Section: This encompasses the definitions of classes, functions, global variables, typedefs, structures, unions, templates, and more.
4. Main() Function: This is the entry point of the program and includes variable declarations, data types, operators, control statements, function calls, and a return statement, etc.

Each of these components is crucial in the successful execution of a program.

Q2. What is the role of the main() function in a C++ program?

The main function is the entry point for every C++ program. It’s where the program starts executing and is mandatory in every C++ program. It coordinates the flow of the program by calling other functions, handles user input and output, and performs various other tasks.

Q3. What are preprocessor directives in C++?

Preprocessor directives perform various pre-processing tasks, such as importing header files, defining constants, and other tasks that need to be done before program execution begins.

Q4. What are variables and data types in C++?

Variables are named locations used to store values/ data. C++ supports various data types such as integers, floating-point numbers, characters, and Boolean values. Each data type has a purpose and each data type has a different range and precision.

Q5. What are control structures in C++?

Control structures are statements used to control/ alter the flow of the program. They include if-else statements, switch statements, loops, while loops, and do-while loops.

Q6. What are functions in C++?

Functions are blocks of code, used to group a set of instructions to perform a specific task. Functions make the code reusable and modular.

Q7. What are classes and objects in C++

Classes and Objects are major components of OOP paradigm in C++. Classes are user-defined data types containing data members and member functions that operate on the data members. Objects are instances of a class that allow access the data members and member functions.

Q8. What is the compilation process for a C++ program?

The compilation process involves preprocessing, compiling, assembly, and linking. Preprocessing executes directives, compilation converts code into machine-readable instructions, assembly turns machine code into object code, and linking connects the object code to necessary libraries to create the final executable file.

Q9. How is a C++ program executed by the computer?

After compilation, the operating system loads the executable file into memory and executes the program. The program interacts with the user and performs tasks until the main function ends, at which point it terminates and releases any resources used.

Test Your Skills: Quiz Time

By now, you must clearly understand the structure of C++ programs. You might also be interested in reading the following:

1. Pointers in C++ | A Roadmap To All Pointer Types (With Examples)
2. New Operator In C++ | Syntax, Working, Uses & More (+Examples)
3. What Are Storage Classes In C++? A Detailed Guide With Examples
4. Array In C++ | Define, Types, Access & More (Detailed Examples)
5. References In C++ | Declare, Types, Properties & More (+Examples)