HSSLIVE Plus One Computer Science Chapter 5: Introduction to C++ Programming Notes

Chapter 5: Introduction to C++ Programming

C++ is a powerful, versatile programming language developed by Bjarne Stroustrup in 1979 as an extension of the C language. It supports multiple programming paradigms, including procedural, object-oriented, and generic programming. This chapter introduces the fundamentals of C++ programming.

History and Features of C++

Origin and Evolution:

• Developed by Bjarne Stroustrup at Bell Labs
• Initially called “C with Classes”
• Renamed to C++ in 1983 (++ is the increment operator in C)
• Standardized by ISO in 1998 (C++98)
• Major updates: C++03, C++11, C++14, C++17, C++20

Key Features:

• Object-oriented programming
• Rich standard library
• Low-level memory manipulation
• High performance
• Platform independence
• Backward compatibility with C
• Support for generic programming through templates
• Exception handling

C++ Development Environment

Components of a C++ Development Environment:

• Text editor or Integrated Development Environment (IDE)
• C++ compiler (g++, Microsoft Visual C++, Clang)
• Debugger
• Build system (Make, CMake)

Popular C++ IDEs:

• Visual Studio
• Code::Blocks
• Dev-C++
• Eclipse CDT
• Qt Creator
• CLion

Structure of a C++ Program

A basic C++ program structure:

// Include directives
#include <iostream>

// Optional namespace declaration
using namespace std;

// Main function
int main() {
    // Statements
    cout << "Hello, World!" << endl;
    
    // Return statement
    return 0;
}

Components Explained:

• Preprocessor Directives: Lines starting with # that are processed before compilation (e.g., #include)
• Namespace: Collection of identifiers that helps prevent naming conflicts
• main() Function: Entry point of every C++ program
• Statements: Instructions that perform actions (terminated by semicolons)
• Return Statement: Indicates the end of the function and returns a value

Basic Input and Output

Standard Output (cout):

#include <iostream>
using namespace std;

int main() {
    cout << "Hello, World!" << endl;  // Prints text
    cout << 42 << endl;               // Prints numbers
    cout << "Sum: " << 5 + 3 << endl; // Combines text and expressions
    return 0;
}

Standard Input (cin):

#include <iostream>
using namespace std;

int main() {
    int age;
    cout << "Enter your age: ";
    cin >> age;
    cout << "You are " << age << " years old." << endl;
    return 0;
}

Comments in C++

Comments are ignored by the compiler and used to explain code:

// This is a single-line comment
/* This is
   a multi-line
   comment */

Variables and Data Types

Variable Declaration:

data_type variable_name = initial_value;

Basic Data Types:

• int: Integer numbers (e.g., -5, 0, 42)
• float: Single-precision floating-point numbers (e.g., 3.14f)
• double: Double-precision floating-point numbers (e.g., 3.14159)
• char: Single characters (e.g., ‘A’, ‘5’, ‘+’)
• bool: Boolean values (true or false)

Example:

int age = 25;
float height = 5.9f;
double pi = 3.14159265359;
char grade = 'A';
bool isStudent = true;

Type Modifiers:

• short: Reduces the size of int
• long: Increases the size of int or double
• signed/unsigned: Determines whether a type can represent negative values

Constants:

const int MAX_STUDENTS = 50;  // Cannot be changed later
#define PI 3.14159  // Preprocessor constant

Operators

Arithmetic Operators:

• Addition: +
• Subtraction: -
• Multiplication: *
• Division: /
• Modulus (remainder): %
• Increment: ++
• Decrement: --

Relational Operators:

• Equal to: ==
• Not equal to: !=
• Greater than: >
• Less than: <
• Greater than or equal to: >=
• Less than or equal to: <=

Logical Operators:

• AND: &&
• OR: ||
• NOT: !

Assignment Operators:

• Simple assignment: =
• Add and assign: +=
• Subtract and assign: -=
• Multiply and assign: *=
• Divide and assign: /=
• Modulus and assign: %=

Type Conversion

Implicit Conversion (Automatic):

int x = 10;
double y = x;  // Automatically converts int to double

Explicit Conversion (Casting):

double pi = 3.14159;
int intPi = (int)pi;  // C-style cast
int intPi2 = static_cast<int>(pi);  // C++ style cast

Basic Programming Examples

Example 1: Area of a Rectangle:

#include <iostream>
using namespace std;

int main() {
    double length, width, area;
    
    cout << "Enter length: ";
    cin >> length;
    
    cout << "Enter width: ";
    cin >> width;
    
    area = length * width;
    
    cout << "Area of rectangle: " << area << endl;
    
    return 0;
}

Example 2: Temperature Conversion:

#include <iostream>
using namespace std;

int main() {
    double celsius, fahrenheit;
    
    cout << "Enter temperature in Celsius: ";
    cin >> celsius;
    
    fahrenheit = (celsius * 9.0/5.0) + 32.0;
    
    cout << celsius << " degrees Celsius is " << fahrenheit << " degrees Fahrenheit." << endl;
    
    return 0;
}

Error Types in C++

Syntax Errors:

• Mistakes in the structure of the code
• Detected during compilation
• Examples: missing semicolons, unmatched parentheses

Semantic Errors:

• Mistakes in the meaning of the code
• May be caught during compilation or at runtime
• Examples: type mismatches, undefined variables

Runtime Errors:

• Errors that occur during program execution
• Examples: division by zero, out-of-bounds array access

Logical Errors:

• Program runs but produces incorrect results
• Most difficult to find and fix
• Examples: incorrect algorithm implementation, incorrect operators

Understanding the basics of C++ programming provides a foundation for exploring more advanced programming concepts in subsequent chapters. As you progress, you’ll build on these fundamental concepts to create more complex and powerful programs.

Chapter 6: Data Types and Operators

Data types and operators are fundamental building blocks in C++ programming. This chapter explores various data types available in C++ and the operations that can be performed on them.

Primitive Data Types

C++ provides several built-in data types:

Integer Types

int: The standard integer type

• Size: Typically 4 bytes (platform-dependent)
• Range: Typically -2,147,483,648 to 2,147,483,647

short: Smaller integer type

• Size: Typically 2 bytes
• Range: Typically -32,768 to 32,767

long: Larger integer type

• Size: Typically 4 bytes (8 bytes on 64-bit systems)
• Range: At least -2,147,483,648 to 2,147,483,647

long long: Even larger integer type

• Size: Typically 8 bytes
• Range: At least -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Example:

int regular = 42;
short small = 123;
long larger = 1234567L;
long long largest = 123456789012345LL;

Floating-Point Types

float: Single-precision floating-point

• Size: Typically 4 bytes
• Precision: About 7 decimal digits

double: Double-precision floating-point

• Size: Typically 8 bytes
• Precision: About 15 decimal digits

long double: Extended-precision floating-point

• Size: Typically 12 or 16 bytes (platform-dependent)
• Precision: At least as much as double, typically more

Example:

float pi_approx = 3.14159f;
double pi_better = 3.141592653589793;
long double pi_precise = 3.141592653589793238L;

Character Types

char: Basic character type

• Size: 1 byte
• Range: -128 to 127 or 0 to 255

wchar_t: Wide character type

• Size: Typically 2 or 4 bytes
• Used for representing larger character sets

char16_t and char32_t: Unicode character types

• char16_t: For UTF-16 encoding (16 bits)
• char32_t: For UTF-32 encoding (32 bits)

Example:

char letter = 'A';
wchar_t wide_letter = L'Ω';
char16_t utf16_char = u'Ω';
char32_t utf32_char = U'Ω';

Boolean Type

bool: Represents true or false values

• Size: Typically 1 byte
• Values: true or false

Example:

bool is_active = true;
bool has_permission = false;

Type Modifiers

Sign Modifiers

• signed: Can represent both positive and negative values (default for most types)
• unsigned: Can represent only non-negative values

Example:

unsigned int positive_only = 500; // Range: 0 to 4,294,967,295
signed int with_sign = -500; // Range: -2,147,483,648 to 2,147,483,647

Derived Data Types

Arrays

Collections of elements of the same type.

Example:

int numbers[5] = {10, 20, 30, 40, 50};
char name[10] = "John";

Pointers

Variables that store memory addresses.

Example:

int number = 42;
int* ptr = &number; // ptr holds the address of number

References

Alternative names for existing variables.

Example:

int original = 10;
int& reference = original; // reference is an alias for original

User-Defined Data Types

Structures (struct)

Groups related variables of different types.

Example:

struct Student {
    string name;
    int age;
    float gpa;
};

Student s1 = {"Rahul", 18, 9.2};

Enumerations (enum)

User-defined types with named constant values.

Example:

enum Day {SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};
Day today = WEDNESDAY;

Classes

Foundation of object-oriented programming, combining data and functions.

Example:

class Rectangle {
private:
    double length;
    double width;
public:
    void setDimensions(double l, double w) {
        length = l;
        width = w;
    }
    double area() {
        return length * width;
    }
};

Type Qualifiers

const

Makes variables unchangeable after initialization.

Example:

const double PI = 3.14159;
// PI = 3.14; // Error: Cannot modify a const variable

volatile

Indicates that a variable might be changed by external factors.

Example:

volatile int sensor_value; // Value might change unexpectedly

mutable

Allows modification of a member variable in a const member function.

Example:

class Example {
private:
    mutable int cache_value;
public:
    int getValue() const {
        cache_value = 42; // Allowed despite const function
        return cache_value;
    }
};

Type Conversion

Implicit Conversion (Coercion)

Automatic type conversion performed by the compiler.

Example:

int i = 10;
double d = i; // int implicitly converted to double

Explicit Conversion (Casting)

Manual type conversion specified by the programmer.

Example:

double d = 3.14159;
int i = (int)d; // C-style cast
int j = static_cast<int>(d); // C++ style cast