Basic structure of cout:

cout << “ … “;

Note:
▪ cout -> Character Output
▪ Defined in the <iostream> header file.
▪ The insertion operator (<<)is used to send data to the standard output (on the console).
▪ ‘endl’ is used to insert a newline character and flush the output buffer.
▪ ‘\n’ is simply a newline character without flushing the buffer.
▪ cout is part of the std namespace.
▪ We can either use the full name std::cout or declare using namespace std; to
avoid writing std:: each time.

Hierarchy of cout, endl, cin:

iostream (Header File)

std (Namespace)

ios (Namespace)

ostream (Base class of output stream)

cout, endl
istream (Base class of input stream)

cin
1. Basic structure of cin:
cin << varaibles;

Note:
▪ cin –> Character Input
▪ Defined in the <iostream> header file.
▪ Reads a string without spaces.
▪ The extraction operator (>>) is used to extract values from input streams.

2. Basic structure of getline:

getline(cin, stringVariable);

Note:
▪ Reads a whole line of input, including spaces.
▪ It automatically terminates when it encounters a newline character.

Advanced Usage
1. Reading Characters
cin.get()is used to read a single character, including whitespace.
char ch;

cout << "Enter a character: ";

cin.get(ch);

cout << "You entered: " << ch << endl;

2. Reading Strings with Spaces

getline()is used to read strings that may contain spaces.

string address;

cout << "Enter your address: ";

getline(cin, address);

cout << "Address: " << address << endl;

3. Clearing the Input Buffer
getline() is often paired with cin.ignore() to handle any leftover newline characters in
the buffer.
Syntax:
cin.ignore(numeric_limits<streamsize>::max(), '\n');

cin.ignore(int n, char delim):

• n: The maximum number of characters to ignore.

• delim: The delimiter character at which to stop ignoring. Typically, this is a newline
character ('\n').

#include <iostream>

#include <limits> // Required for numeric_limits

using namespace std;

int main() {

int age;

string name;

cout << "Enter your age: ";

cin >> age;

// User enters 25, but a newline '\n' is left in the buffer

cin.ignore(numeric_limits<streamsize>::max(), '\n');

// Clear the buffer

cout << "Enter your full name: ";

getline(cin, name);

// Now getline() reads the full name, not the leftover newline

cout << "Age: " << age << ", Name: " << name << endl;

return 0;

}
4. Skipping Specific Characters
We might want to skip a certain number of characters or up to a specific character.
char ch;

cout << "Enter a string ending with 'x': ";

cin >> ch; // Assume input is "Hello x"

cin.ignore(100, 'x');

// Ignore up to 100 characters or until 'x' is found

cout << "Remaining input: ";

cin >> ch;

cout << ch << endl;

// Outputs whatever character comes after 'x'

5. By default cin.ignore()
cin.ignore() without arguments will skip one character from the input stream. This is
equivalent to calling cin.ignore(1).
#include <iostream>

using namespace std;

int main() {

char ch;

cout << "Enter a character: ";

cin >> ch;

cout << "You entered: " << ch << endl;

cin.ignore(); // Skips the newline character

cout << "Enter another character: ";

cin >> ch;

 cout << "You entered: " << ch << endl;

return 0;

6. Input Validation
If the user enters data that doesn’t match the type of the variable (e.g., entering a letter when
an int is expected), cin will fail, and the variable will not be modified. To handle such cases,
use cin.fail()
int number;

cout << "Enter an integer: ";

cin >> number;

if (cin.fail()) {

cout << "Invalid input, not an integer." << endl;

cin.clear();

// Clear the fail state

cin.ignore(numeric_limits<streamsize>::max(), '\n');

// Ignore bad input

} else {

cout << "You entered: " << number << endl;

}
setprecesion
setprecision is a manipulator in C++ that sets the number of digits to be displayed after the
decimal point when outputting floating-point numbers. It is defined in the <iomanip> header
file.
std::cout << std::setprecision(n);

n: The number of significant digits to display. If used with std::fixed or

std::scientific, it specifies the number of digits after the decimal point.

1. Without std::fixed

Sets the total number of significant digits (both before and after the decimal point).
#include <iostream>

#include <iomanip> // Include header for setprecision

using namespace std;

int main() {

double num = 123.456789;

cout << "Default precision: " << num << endl; // Default precision

cout << "Precision set to 3: " << setprecision(3) << num << endl; // Total
3 significant digits

cout << "Precision set to 5: " << setprecision(5) << num << endl; // Total
5 significant digits

return 0;

Output:

Default precision: 123.457

Precision set to 3: 123

Precision set to 5: 123.46

2. With std::fixed
Sets the number of digits to display after the decimal point.
#include <iostream>

#include <iomanip>

using namespace std;

int main() {

double num = 123.456789;

cout << fixed; // Use fixed notation for floating-point numbers

cout << "Precision set to 2: " << setprecision(2) << num << endl;

// 2 digits after the decimal point

cout << "Precision set to 4: " << setprecision(4) << num << endl;

// 4 digits after the decimal point

return 0;

Output:

Precision set to 2: 123.46

Precision set to 4: 123.4568

3. Controlling Precision with std::scientific

#include <iostream>

#include <iomanip>

using namespace std;

int main() {

double num = 123.456789;

cout << scientific; // Use scientific notation

cout << "Precision set to 2: " << setprecision(2) << num << endl;
 // 2 digits after the decimal point

cout << "Precision set to 4: " << setprecision(4) << num << endl;

// 4 digits after the decimal point

return 0;

Output:

Precision set to 2: 1.23e+02

Precision set to 4: 1.2346e+02

Note:
By default, cout prints floating-point numbers with up to 6 digits of precision. We can change
this using setprecision.

• Basic Structure:

• Syntax:

switch (expression) {
case constant1:
// Code to execute for constant1
break;
case constant2:
// Code to execute for constant2
break;
...
default:
// Code to execute if no case matches
}

• Expression Type:

• The expression in a switch statement must be of integer type (e.g., int, char, enum).
• Cannot use floating-point types (float, double) or non-integer types.

• Case Labels:
 • case labels must be compile-time constants and of the same type as the expression.
• Each case label must be unique within the same switch statement.

• break Statement:

• Purpose: Terminates the switch statement and exits it.

• Omission: Without break, execution continues to the next case (known as "fall-through").
• Fall-through Behavior: Multiple cases can share the same block of code if break is
omitted.

• Optional default Case:

• The default case is optional.

• It is executed if none of the case values match the expression.
• Can be placed anywhere in the switch block but is usually placed at the end.

• Fall-through Behavior:

• If a case does not end with a break, execution will continue to the next case (even if it
doesn't match).
• Used intentionally to handle multiple cases with shared code.

• Efficiency:

• Generally more efficient than a series of if-else statements.

• Many compilers optimize switch statements using jump tables.

• Nested switch Statements:

• switch statements can be nested inside each other.

• Should be used carefully to avoid complex and difficult-to-read code.

• Limitations:

• case labels must be constant expressions.

• switch expression cannot evaluate to non-integer types.
• Not suitable for complex conditions or ranges (use if-else in such cases).

• Common Use Cases:

• Handling menu-driven programs.

• Processing command-line arguments.
• Managing key events.
• Simplifying multi-way branching where the variable has a limited set of distinct values.
min() and max() are functions used to find the minimum and maximum values, respectively,
from a set of values. These functions are defined in the <algorithm> header.

min() and max() with More Than Two Arguments

1. Directly pass multiple arguments: (Alternative of Initializer list)

#include <iostream>

#include <algorithm> // For std::min

int main() {

int a = 3, b = 7, c = 2, d = 8, e = 5;

int minimum = std::min({a, b, c, d, e});

std::cout << "The minimum value is: " << minimum << std::endl;

return 0;

2. Using initializer lists:

#include <algorithm>

#include <initializer_list>

int main() {

initializer_list<int> values = {10, 5, 8, 12};

int smallest = min(values.begin(), values.end());

int largest = max(values.begin(), values.end());

cout << "Smallest value: " << smallest << endl;

cout << "Largest value: " << largest << endl;

return 0;

}
The swap() function is used to exchange the values of two variables. It's a part of the
<algorithm> header and can be used with various data types, including built-in types, user-
defined types, and even standard library containers.
#include <iostream>

#include <algorithm> // For std::swap

int main() {

int x = 10, y = 20;

std::cout << "Before swap:" << std::endl;

std::cout << "x = " << x << ", y = " << y << std::endl;

std::swap(x, y); // Swapping the values

std::cout << "After swap:" << std::endl;

std::cout << "x = " << x << ", y = " << y << std::endl;

return 0;

cin – like scanf() (Without space and enter)

fgets() – with space, and enter (String size become 1 more, that is the enter input)
getline() – with space, but without enter (String size remains as it is, since it doesn’t take the enter
as input)
Note: Pressing enter means end of the input.

The header file for C and C++ is ‘bits/stdc++.h’. (#include <bits/stdc++.h>)