Module 2: Basics of C++

Variables and Data Types

Introduction

In C++, variables are used to store data that can be manipulated by the program. Each variable must be declared with a specific data type, which determines the kind of data it can store. Understanding variables and data types is fundamental to programming in C++.

Variables

A variable is a named storage location in memory that holds a value. The value of a variable can change during the execution of a program.

Declaration and Initialization

To declare a variable, you specify the data type followed by the variable name. You can also initialize the variable with a value at the time of declaration.

Syntax:

<datatype> <variable_name> = <value>;

Example:

int age = 25;

In this example, int is the data type, age is the variable name, and 25 is the initial value assigned to the variable.

Rules for Naming Variables

• Must begin with a letter or an underscore (_).
• Can contain letters, digits, and underscores.
• Cannot be a reserved keyword.

Data Types

C++ provides several built-in data types to represent different kinds of data. These data types can be categorized into fundamental, derived, and user-defined types.

Fundamental Data Types

1. Integer Types
   • int: Represents whole numbers.
   • short, long: Variants of intwith different sizes.

Example:
int count = 100;

2. long population = 7000000;
3. Floating-Point Types
   • float: Represents numbers with fractional parts.
   • double: Represents double-precision floating-point numbers.

Example:
float temperature = 36.5;

4. double distance = 12345.6789;
5. Character Type
   • char: Represents a single character.
6. Example:
   char grade = ‘A’;
7. Boolean Type
   • bool: Represents trueor false
8. Example:
   bool isPassed = true;

Derived Data Types

1. Arrays: Collection of elements of the same data type.
2. Pointers: Variables that store the memory address of another variable.
3. References: Alias for another variable.

User-Defined Data Types

1. Structures (struct)
2. Classes
3. Enumerations (enum)

Type Modifiers

C++ provides type modifiers to alter the size and range of data types.

• signed
• unsigned
• short
• long

Example:

unsigned int positiveNumber = 123;

long double largeDecimal = 123456.7890123;

Type Conversion

Type conversion is the process of converting a variable from one data type to another. It can be either implicit or explicit.

Implicit Conversion

Also known as “type coercion,” it automatically converts a smaller data type to a larger data type.

Example:

int num = 10;

double result = num; // Implicit conversion from int to double

Explicit Conversion (Type Casting)

Explicit conversion is performed using the cast operator.

Example:

double pi = 3.14159;

int truncatedPi = (int)pi; // Explicit conversion from double to int

Conclusion

Understanding variables and data types is crucial in C++ programming. They form the building blocks for storing and manipulating data. By mastering these basics, you’ll be well-prepared to tackle more complex programming concepts.

Input and Output in C++

Introduction

Input and output operations are essential for interacting with users in a C++ program. The standard library provides facilities to handle input from the keyboard and output to the screen.

Output Using cout

The cout object, defined in the <iostream> header, is used to output data to the standard output (usually the screen).

Syntax:

std::cout << <expression>;

Example:

#include <iostream>

 

int main() {

std::cout << “Hello, World!” << std::endl;

return 0;

}

In this example, std::cout outputs the string “Hello, World!” followed by a newline character.

Input Using cin

The cin object, also defined in the <iostream> header, is used to read input from the standard input (usually the keyboard).

Syntax:

std::cin >> <variable>;

Example:

#include <iostream>

 

int main() {

int age;

std::cout << “Enter your age: “;

std::cin >> age;

std::cout << “You entered: ” << age << std::endl;

return 0;

}

In this example, the user is prompted to enter their age, which is then read into the age variable and printed back to the screen.

Combining cin and cout

You can combine cin and cout to create interactive programs.

Example:

#include <iostream>

 

int main() {

std::string name;

std::cout << “Enter your name: “;

std::cin >> name;

std::cout << “Hello, ” << name << “!” << std::endl;

return 0;

}

In this example, the program reads the user’s name and greets them with a personalized message.

Understanding input and output in C++ is fundamental for creating interactive applications. Using cin and cout, you can easily manage user input and display output, making your programs more dynamic and user-friendly.

Operators and Expressions in C++

In C++, operators are symbols that perform operations on variables and values. These operations could be mathematical, logical, or relational in nature. C++ includes a wide variety of operators, such as arithmetic operators, comparison operators, logical operators, and assignment operators.

Key types of operators in C++:

1. Arithmetic Operators: Used to perform mathematical operations like addition, subtraction, multiplication, division, and modulus.
2. Relational Operators: Used to compare two values (e.g., ==, !=, <, >, <=, >=).
3. Logical Operators: Used to combine multiple conditions (e.g., &&, ||, !).
4. Bitwise Operators: Perform bit-level operations (e.g., &, |, ^, <<, >>).
5. Assignment Operators: Used to assign values to variables (e.g., =, +=, -=).
6. Unary Operators: Operate on a single operand (e.g., ++, –, !).
7. Ternary Operator: A shorthand for an if-elsestatement (e.g., condition ? expr1 : expr2).
8. Type-Casting Operators: Used to convert one data type to another (e.g., static_cast, dynamic_cast).

An expression in C++ is a combination of operators and operands that results in a value. Expressions can be simple, involving just constants and variables, or complex, involving multiple operators and nested operations.

Understanding how operators and expressions work is fundamental for writing efficient and functional code in C++. Mastery of these concepts enables developers to write complex logic with minimal lines of code.

Control Structures (if, switch, loops) in C++

Control structures in C++ allow you to control the flow of execution in your program based on certain conditions or repetitive tasks. These structures enable decision-making and looping, which are crucial for writing efficient and dynamic code.

1. If Statement:The ifstatement is used to execute a block of code only if a specified condition is true. If the condition evaluates to false, the code block inside the if is skipped.

2. If-else Statement:The if-elsestatement provides an alternative set of instructions. If the condition evaluates to true, one block is executed, and if false, another block is executed.

3. If-else if-else Statement:When you have multiple conditions to check, the if-else if-elseladder allows you to check multiple conditions in sequence.

4. Switch Statement:The switchstatement provides an easy way to dispatch execution to different parts of code based on the value of a variable. It is used when you have multiple values to check against a single variable.

5. Loops:Loops are control structures that repeat a block of code multiple times. The three primary types of loops in C++ are:

For Loop: Used when the number of iterations is known beforehand.

While Loop: Executes a block of code as long as the specified condition is true.

Do-while Loop: Similar to the while loop, but it guarantees that the block of code will execute at least once, even if the condition is false initially.

Control structures such as if, switch, and loops are essential for implementing logic, handling decision-making, and managing repetitive tasks in C++ programs. Mastery of these structures enables developers to create dynamic and flexible applications that can respond to changing conditions.

Functions in C++ (Declaration, Definition, and Calling)

Functions in C++ allow you to organize your code into reusable blocks that can be executed whenever needed. They help in improving code modularity, readability, and maintainability. Functions are defined once but can be called multiple times throughout the program.

1. Function Declaration:

A function declaration, also known as a function prototype, tells the compiler about the function’s name, return type, and parameters (if any) without providing the actual body of the function. The declaration allows the function to be used before its definition.

Syntax:

Example:

2. Function Definition:

A function definition provides the actual implementation of the function. It contains the body of the function, where the functionality of the function is specified.

Syntax:

Example:

3. Function Calling:

Once a function is declared and defined, it can be called from the main function or other functions. When calling a function, you pass values (called arguments) to the function’s parameters, and the function returns a value (if specified) back to the caller.

Syntax:

Example:

Key Points:

• Return Type:Defines the type of data that the function will return. Use void if the function doesn’t return anything.
• Parameters:Functions can accept parameters, allowing you to pass values to the function. These are specified inside the parentheses during both the declaration and definition.
• Function Overloading:C++ supports function overloading, which allows multiple functions to have the same name but with different parameters.

Functions are essential in C++ to break down complex problems into smaller, manageable sub-problems. By using functions, you can ensure that your code is modular, reusable, and easier to debug and maintain.