Category: 1. Basics

Omitting Namespace

You can explicitly use the std:: prefix for standard library objects and functions instead of using the “using namespace std“.

Example of Omitting Namespace

Here’s a simple example to illustrate this −

#include <iostream>#include <string>intmain(){
   std::string greeting ="Hello,TutorialsPoint Learner!";
   std::cout << greeting << std::endl;return0;}

In this example we had directly used std::string and std::count instead of using using namespace std;

When and Why to Omit Namespaces?

Omitting namespaces in C++ can be beneficial in several scenarios. Here we will discuss some key reasons and scenarios −

• Large projects − Using “using namespace std” in large codebases may create issues like naming conflicts, especially when working with multiple libraries and overlapping.
• Library Development − While creating libraries it is important to avoid “polluting global namespace” (which occurs when too many identifiers are declared in global namespace such as function, classes, variables etc) to prevent conflicts with other libraries. Using std:: helps avoid conflicts with other libraries or user-defined names which might have the same identifiers.
• Improved Readability and Better Maintenance − std:: makes it easier to track dependencies and to understand the origins of various functions and objects, which is helpful during debugging and maintenance.

Printing “Hello, World!” is the first program in C++. Here, this prints “Hello, World” on the console (output screen). To start learning C++, it is the first step to print sometime on the screen.

C++ Program to Print “Hello, World!”

Let us see the first C++ program that prints “Hello, World!” −

Open Compiler

// First C++ program #include<iostream>usingnamespace std;intmain(){
  cout <<"Hello, World!";return0;}

Output

This program will print “Hello, World!” on the output screen. The output will be −

Hello, World!

Parts of C++ “Hello, World!” Program

Here is the breakdown of the above code and all elements used in the above code −

1. Comment Section (// First C++ program)

Comments are used to specify a textual line that is not supposed to be executed when we compile the code. The compiler ignores the line, and proceeds to the next line. These are used for better readability and explanation of code in the comments section.

This is the comment −

// First C++ program

2. Preprocessor Directive (#include <iostream>)

The #include is known as a pre-processor directive in C++. It is used to include header files with specific methods and elements. Multiple #include statements are used to apply different header files in the program. The iostream is the header file that defines functions and operations related to the input/output stream.

The statement is used in the program is −

#include <iostream>

3. Namespace (using namespace std;)

Namespaces are used to differentiate code blocks with the same method names. In this program, the using namespace std; is used to set the namespace as standard for users to apply all standard methods in programs.

Here is the code statement used in the program −

using namespace std;

4. The main() Function (int main(){…})

The main() function is the default starting point of any C++ program. It is compulsory for any C++ program to have a main function. The program logics are written inside the main program. The main function body is enclosed inside parenthesis ({}).

The main() function part is −

int main() {
  cout << "Hello, World!";
  return 0;
}

5. Printing Statement (cout)

The print/output statement is cout followed by “<<” operator. This is used to print the given parameters specified in the statement on the screen. We can also print multiple elements in a single cout block.

The print statement is −

cout << "Hello, World!";

6. Return Statement (return 0;)

The return statement is also known as the exit statement. It is used to exit from the corresponding function. The “return 0” is the default statement to exit from the main program.

Here is the return statement used in the program −

return 0;

Compile and Run “Hello, World!” Program

The “Hello, World!” program can be compiled by using the Edit & Run button. You can also open our online C++ compiler, write the program, and compile it there.

The standard way to compile and run the C++ program is explained here: Compile and Run a C++ Program.

While writing program in any language, you need to use various variables to store various information. Variables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in memory.

You may like to store information of various data types like character, wide character, integer, floating point, double floating point, boolean etc. Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory.

Primitive Built-in Types

C++ offers the programmer a rich assortment of built-in as well as user defined data types. Following table lists down seven basic C++ data types −

Several of the basic types can be modified using one or more of these type modifiers −

• signed
• unsigned
• short
• long

The following table shows the variable type, how much memory it takes to store the value in memory, and what is maximum and minimum value which can be stored in such type of variables.

The size of variables might be different from those shown in the above table, depending on the compiler and the computer you are using.

Example

Following is the example, which will produce correct size of various data types on your computer.

Open Compiler

#include <iostream>usingnamespace std;intmain(){
   cout <<"Size of char : "<<sizeof(char)<< endl;
   cout <<"Size of int : "<<sizeof(int)<< endl;
   cout <<"Size of short int : "<<sizeof(shortint)<< endl;
   cout <<"Size of long int : "<<sizeof(longint)<< endl;
   cout <<"Size of float : "<<sizeof(float)<< endl;
   cout <<"Size of double : "<<sizeof(double)<< endl;
   cout <<"Size of wchar_t : "<<sizeof(wchar_t)<< endl;return0;}

This example uses endl, which inserts a new-line character after every line and << operator is being used to pass multiple values out to the screen. We are also using sizeof() operator to get size of various data types.

When the above code is compiled and executed, it produces the following result which can vary from machine to machine −

Size of char : 1
Size of int : 4
Size of short int : 2
Size of long int : 4
Size of float : 4
Size of double : 8
Size of wchar_t : 4

Example

Following is another example:

Open Compiler

#include <iostream>#include <limits>usingnamespace std;intmain(){

std::cout &lt;&lt;"Int Min "&lt;&lt; std::numeric_limits&lt;int&gt;::min()&lt;&lt; endl;
std::cout &lt;&lt;"Int Max "&lt;&lt; std::numeric_limits&lt;int&gt;::max()&lt;&lt; endl;
std::cout &lt;&lt;"Unsigned Int  Min "&lt;&lt; std::numeric_limits&lt;unsignedint&gt;::min()&lt;&lt; endl;
std::cout &lt;&lt;"Unsigned Int Max "&lt;&lt; std::numeric_limits&lt;unsignedint&gt;::max()&lt;&lt; endl;
std::cout &lt;&lt;"Long Int Min "&lt;&lt; std::numeric_limits&lt;longint&gt;::min()&lt;&lt; endl;
std::cout &lt;&lt;"Long Int Max "&lt;&lt; std::numeric_limits&lt;longint&gt;::max()&lt;&lt; endl;
std::cout &lt;&lt;"Unsigned Long Int Min "&lt;&lt; std::numeric_limits&lt;unsignedlongint&gt;::min()&lt;&lt;endl;
std::cout &lt;&lt;"Unsigned Long Int Max "&lt;&lt; std::numeric_limits&lt;unsignedlongint&gt;::max()&lt;&lt; endl;}</code></pre>


Derived Data Types



Data types which are obtained from pre-defined data types in C++ are known as Derived Data Types. These can be classified into four categories, namely −



1. Function



A function is the simplest form of user-defined data type. It includes a return type, a function name and input parameters.



Syntax



return_type function_name(input_param1, input_param2…){<function_body>}



Example



Open Compiler



#include <iostream>usingnamespace std;

string func(int n){//returns if n is odd or evenif(n%2)return"Given number is Odd !";elsereturn"Given number is Even !";}intmain(){int a;//enter a number
   cin>>a;
   cout<<func(a);//a simple function to check if//number is odd or evenreturn0;}



Output



Given number is Even !




2. Array



An array is a series of elements of same data type. Elements of an array are stored in contiguous memory locations in the storage.



Syntax



data_type array_name[array_size];



Example



Open Compiler



#include <iostream>usingnamespace std;intmain(){int arr[5]={1,2,3,2,1};//define an integer array of size 5for(auto it:arr)
  cout&lt;&lt;it&lt;&lt;" ";//print the elements of arrayreturn0;}</code></pre>


Output



1 2 3 2 1 




3. Pointer



A pointer is a reference to an element defined previously. The value of the pointer returns the address location of the element which is associated with it.



Syntax



data_type * pointer_name=& variable_name;



Example



Open Compiler



#include <iostream>usingnamespace std;intmain(){int a=20;//declare variable aint*p=&a;//assign pointer to a
   cout<<"Address of variable a: "<<p<<endl;
   cout<<"Value of variable a: "<<*p<<endl;return0;}



Output



Address of variable a: 0x7ffc49a8637c
Value of variable a: 20




4. Reference



A reference variable is used to create a copy of a variable with the same reference. Hence, changes made to the reference variable also reflect on the original variable.



Syntax



data_type & reference_name= variable_name;



Example



Open Compiler



#include <iostream>usingnamespace std;intmain(){int c=11;int& refer=c;

   cout<<"Initially value of integer is: "<<c<<endl;

   refer=121;
   cout<<"After changing value using refer variable :"<<c<<endl;return0;}



Output



Initially value of integer is: 11
After changing value using refer variable :121




User-Defined Data Types



Data types which are defined by the user intuitively without using any pre-defined data types are known as User-Defined Data Types. These data types can be further categorized into five types, namely −



1. Class



A class is a defined in Object Oriented Programming as a custom data type which is used to construct an object. It is the framework of an object, and it can include constructors, methods and OOP concepts like Polymorphism, Inheritance, etc.



Syntax



classClass_name{<classbody>class_name(parameters){<constructor body>}

   return_type method_name(paremeters){<method body>}}



Example



Open Compiler



#include <iostream>usingnamespace std;classTP{public:
  string tp;voidprint(){
     cout&lt;&lt;tp&lt;&lt;endl;}};intmain(){
   TP object;
   object.tp="I Love Tutorialspoint !!!";
   object.print();return0;}



Output



I Love Tutorialspoint !!!




2. Structure (struct)



In structure data type, the user can introduce multiple primitive data types inside the struct body.



Syntax



structstruct_name{
   data_type1 var_name1;
   data_type2 var_name2;
   …
}



Example



Open Compiler



#include <iostream>usingnamespace std;structTP{
   string tp;int grade;};intmain(){
   TP object;
   object.tp="I Love Tutorialspoint !!!";
   object.grade=10;

   cout<<object.tp<<endl;
   cout<<"How much would you rate it?"<<" : "<< object.grade;return0;}



Output



I Love Tutorialspoint !!!
How much would you rate it? : 10




3. Union



Union is similar to a structure. In this, the memory location of all variables is same, and all variables share the same reference. Hence, a change in one value leads to all other values getting changed.



Syntax



union union_name{
   data_type var_name1;
   data_type var_name2;};



Example



Open Compiler



#include <iostream>usingnamespace std;union TP{int tp1,tp2;};intmain(){union TP t;
   t.tp1=2;
   cout<<"Value of tp1 initially: "<<t.tp1<<endl;

   t.tp2=4;
   cout<<"When we change tp2, value of tp1 is : "<<t.tp1<<endl;return0;}



Output



Value of tp1 initially: 2
When we change tp2, value of tp1 is : 4




4. Enumeration (Enum)



Enumeration or simply enum is a user-defined data type that is used to give name to integer constants in a program. This increases the user-readability of a program.



Syntax



enumenum_name{
   var¬_name1 , var_name2, …
}



Example



Open Compiler



#include <iostream>usingnamespace std;enumTP{ C, Java, Python, Ruby, Kotlin, Javascript, TypeScript, Others};intmain(){enumTP course;
   cout<<"Which course do you love the most?"<<endl;

   course=Kotlin;
   cout<<"I love the "<<course+1<<"th course !!!";return0;}



Output



Which course do you love the most?
I love the 5th course !!!




typedef Declarations



You can create a new name for an existing type using typedef. Following is the simple syntax to define a new type using typedef −



typedef type newname;



For example, the following tells the compiler that feet is another name for int −



typedefint feet;



Now, the following declaration is perfectly legal and creates an integer variable called distance −



feet distance;



Enumerated Types



An enumerated type declares an optional type name and a set of zero or more identifiers that can be used as values of the type. Each enumerator is a constant whose type is the enumeration.



Creating an enumeration requires the use of the keyword enum. The general form of an enumeration type is −



enumenum-name { list of names } var-list;



Here, the enum-name is the enumeration's type name. The list of names is comma separated.



For example, the following code defines an enumeration of colors called colors and the variable c of type color. Finally, c is assigned the value "blue".



enumcolor{ red, green, blue } c;
c = blue;



By default, the value of the first name is 0, the second name has the value 1, and the third has the value 2, and so on. But you can give a name, a specific value by adding an initializer. For example, in the following enumeration, green will have the value 5.



enumcolor{ red, green =5, blue };



Here, blue will have a value of 6 because each name will be one greater than the one that precedes it.