B.Sc.

CSIT 2nd C++

Unit 2: Basics of C++ programming

C++ Program Structure, Character Set and Tokens, Data Type, Type Conversion, Preprocessor Directives,
Namespace, Input/Output Streams and Manipulators, Dynamic Memory Allocation with new and delete,
Control Statements.

Functions: Function Overloading, Inline Functions, Default Argument, Pass by Reference, Return by
Reference, Scope and Storage Class.

Pointers: Pointer variables declaration & initialization, Operators in pointers, Pointers and Arrays, Pointer and
Function.

✅ 1. C++ Program Structure

cpp

#include <iostream> // Preprocessor directive

using namespace std; // Namespace

int main() { // Main function

cout << "Hello, World!" << endl; // Output
return 0;
}

✅ 2. Character Set and Tokens

• Character Set: Includes letters, digits, special symbols (+ - * /, etc.), and whitespace.
• Tokens: Smallest elements of a program.
o Keywords: int, return, if, etc.
o Identifiers: User-defined names (main, cout)
o Constants: 5, 3.14, 'A'
o Operators: +, -, =, ==
o Punctuators: ;, {}, ()

✅ 3. Data Types

Built-in Types:

cpp

int a = 10;
float b = 5.5;
char c = 'A';
bool d = true;

Derived/User-defined:

Er. Sital Prasad Mandal 1|Page

 B.Sc. CSIT 2nd C++

• Arrays, structures, unions, enums, classes.

✅ 4. Type Conversion

• Implicit (Automatic):

cpp

int a = 10;
float b = a; // a is converted to float automatically

• Explicit (Type Casting):

cpp

float a = 5.5;
int b = (int) a; // a is explicitly cast to int

✅ 5. Preprocessor Directives

• Start with # and are processed before compilation.

cpp

#include <iostream>
#define PI 3.14159

✅ 6. Namespace

• Used to avoid name conflicts.

cpp

namespace MySpace {
int val = 10;
}
int main() {
cout << MySpace::val;
}

✅ 7. Input/Output Streams and Manipulators

cpp

#include <iostream>
#include <iomanip> // for manipulators
using namespace std;

Er. Sital Prasad Mandal 2|Page

 B.Sc. CSIT 2nd C++
int main() {
int x = 10;
cout << setw(5) << x; // manipulator sets width
}

• cin, cout for input/output

• setw(), setprecision(), fixed, left, right from <iomanip>

✅ 8. Dynamic Memory Allocation with new and delete

In C++, dynamic memory allocation allows you to allocate memory at runtime using the
new and delete operators. This is useful when the size of memory needed is not known at
compile time or when you want to manage memory explicitly.
cpp

int* ptr = new int; // Allocates memory

*ptr = 5;

delete ptr; // Deallocates memory

int* arr = new int[5]; // Array allocation

delete[] arr; // Array deallocation

✅ 9. Control Statements

Conditional

cpp

if (a > b) { ... }
else if (a == b) { ... }
else { ... }

Loops

cpp

for (int i = 0; i < 5; ++i) { ... }

while (condition) { ... }
do { ... } while (condition);

Jump Statements

cpp

break; continue; return;

Er. Sital Prasad Mandal 3|Page

 B.Sc. CSIT 2nd C++

✅ 1. Function Overloading

• Same function name, different parameters.

cpp

void show(int a) {
cout << "Integer: " << a << endl;
}

void show(double b) {
cout << "Double: " << b << endl;
}

✅ 2. Inline Functions

• Suggests the compiler to insert the function code directly where it's called.

cpp

inline int square(int x) {

return x * x;
}

Best for small, frequently called functions. Avoid complex logic.

✅ 3. Default Arguments

• Provide default values for parameters.

cpp

void greet(string name = "RAM") {

cout << "Hello, " << name << endl;
}

Must be specified from right to left.

✅ 4. Pass by Reference

Function gets access to the original variable.

#include <iostream>
using namespace std;

void update(int &x) {

Er. Sital Prasad Mandal 4|Page

 B.Sc. CSIT 2nd C++

x += 5;
}

int main() {
int a = 10;
update(a);
cout << a; // Output will be 15
return 0;
}

• int &x means x is a reference to an int variable passed into the function.

• x += 5; increases the value of the original variable by 5.

✅ 5. Return by Reference

• Function returns a reference to a variable (use with caution).

cpp

int& getRef(int &x) {

return x;
}

Avoid returning reference to local variables—they are destroyed after function ends.

Explanation:

• int &x: The parameter x is passed by reference, so the function receives a reference to the
original variable.
• int& getRef(...): The function returns a reference to the original variable, not a copy.

Why Use This?

Returning a reference allows the caller to access or modify the original variable.

#include <iostream>
using namespace std;

int& getRef(int &x) {

return x;
}

int main() {
int a = 10;
getRef(a) = 20; // Modifies 'a' directly through the reference
cout << a; // Output will be 20
return 0;

Er. Sital Prasad Mandal 5|Page

 B.Sc. CSIT 2nd C++

In this example, getRef(a) = 20; sets a to 20 because the function returns a reference to a.

✅ 6. Scope and Storage Classes

Scope Types:

• Local – inside functions or blocks

• Global – declared outside all functions
• Function scope – labels used in goto
• Class/namespace scope

Storage Classes:

Storage Class Keyword Scope Lifetime Default Initial Value

Automatic auto Local Within block Garbage
External extern Global Entire program Zero (if global)
Static static Local/Global Entire program Zero (if global)
Register register Local Within block Garbage (stored in CPU register if possible)
cpp

static int count = 0; // Retains value between calls

✅ 1. Pointer Variable Declaration & Initialization

A pointer stores the memory address of another variable.

cpp

int a = 10;
int* p; // Declaration
p = &a; // Initialization with address of 'a'

cout << *p; // Outputs: 10 (dereferencing p gives value at that address)

*p = 20; // Changes value of 'a' to 20
cout << a; // Outputs: 20

✅ 2. Operators in Pointers

• & (Address-of): Gives address of a variable

Er. Sital Prasad Mandal 6|Page

 B.Sc. CSIT 2nd C++

• * (Dereference): Accesses the value at a memory address

cpp

cout << "Address of a: " << &a << endl;

cout << "Pointer p: " << p << endl; // Address stored in p
cout << "Value at p: " << *p << endl; // Dereferencing

✅ 3. Pointers and Arrays

Pointers can iterate over arrays using arithmetic.

cpp

int arr[3] = {10, 20, 30};

int* p = arr; // Same as &arr[0]

cout << *p << endl; // 10

cout << *(p + 1) << endl; // 20

Arrays and pointers are closely related in C++, though not the same.

✅ 4. Pointers and Functions

a) Pass by Pointer

cpp

void update(int* p) {

*p = *p + 1;
}

int main() {
int a = 5;
update(&a); // Pass address
cout << a; // 6
}

b) Pointer to Function

You can pass functions as arguments using function pointers.

cpp

void greet() {
cout << "Hello!" << endl;
}

int main() {
Er. Sital Prasad Mandal 7|Page
 B.Sc. CSIT 2nd C++
void (*funcPtr)() = greet;
funcPtr(); // Calls greet
}

• Declares a function pointer funcPtr that can point to functions returning void and taking no
parameters.
• Initializes funcPtr with the address of greet.
• Invokes the function through the pointer, so it calls greet().

#include <iostream>
using namespace std;

void greet(int a) {
cout << "Hello!" << a << endl;
}

int main() {
void (*funcPtr)(int) = greet; // Correct pointer type
funcPtr(5); // Output: Hello!5
return 0;
}

---------------------------------------------------------------------------------------------------------------------
Review

1. C++ Program Structure

A C++ program typically consists of:

• Preprocessor Directives: Instructions to the compiler (e.g., #include).

• Namespace: Avoids name conflicts (e.g., using namespace std;).
• Main Function: Entry point of the program (int main()).
• Statements and Blocks: Code inside {} to perform tasks.

2. Character Set and Tokens

• Character Set: Includes letters (A-Z, a-z), digits (0-9), special characters (e.g., @, #), and
whitespace.
• Tokens: Basic units of a program, including:
o Keywords: Reserved words (e.g., int, if).
o Identifiers: User-defined names (e.g., variable names).
o Literals: Constants (e.g., 42, "hello").
o Operators: Symbols (e.g., +, =).
o Punctuators: Braces, parentheses, semicolons, etc.

3. Data Types

C++ supports:

Er. Sital Prasad Mandal 8|Page

 B.Sc. CSIT 2nd C++

• Basic Types: int, float, double, char, bool.

• Derived Types: Arrays, pointers, references.
• User-Defined Types: struct, class, enum.
• Modifiers: signed, unsigned, short, long.

4. Type Conversion

• Implicit: Automatic conversion (e.g., int to float during arithmetic).

• Explicit: Using casting (e.g., static_cast<double>(intVar)).

5. Preprocessor Directives

Instructions processed before compilation:

• #include: Includes libraries (e.g., #include <iostream>).

• #define: Defines macros (e.g., #define PI 3.14).
• #ifdef, #endif: Conditional compilation.

6. Namespace

• Groups identifiers to avoid name conflicts.

• Example: std namespace contains cout, cin.
• Usage: using namespace std; or std::cout.

7. Input/Output Streams and Manipulators

• Input: cin for reading data.

• Output: cout for displaying data.
• Manipulators: Format output (e.g., setw, setprecision from <iomanip>).

8. Dynamic Memory Allocation with new and delete

• new: Allocates memory dynamically (e.g., int* ptr = new int;).

• delete: Frees memory (e.g., delete ptr;).
• Arrays: int* arr = new int[10]; delete[] arr;.

9. Control Statements

• Conditional: if, else if, else, switch.

• Loops: for, while, do-while.
• Jump: break, continue, return.

Er. Sital Prasad Mandal 9|Page