C++ Programming

Last Modified: 2/12/2025

Ⅰ C++ Fundamentals

1 C & C++ Introduction

1. C/C++ is a compiled language.

2. C/C++ compilers map C/C++ programs into architecture-specific machine code (string of 0s and 1s).

   • Unlike Java, which converts to architecture-independent bytecode (run by JVM => Java Virtual Machine).
   • Unlike Python, which directly interprets the code.
   • Main difference is when your program is mapped to low-level machine instructions, CPU will directly interprets and runs.

Compilation Advantages

• Excellent run-time performance:

  Generally much faster than Python or Java for comparable code because it optimizes for the given architecture.

• Fair compilation time:

  Enhancements in compilation procedure (Makefiles) allow us to recompile only the modified files.

Compilation Disadvantages

• Compiled files, including the executable, are arcitecture-specific (CPU type and OS).

  Executable must be rebuilt on each new system, i.e., “porting your code” to a new architecture.

• Instead of “Edit -> Run [repeat]” cycle, “Edit -> Compile -> Run [repeat]” iteration cycle can be slow.

Normal C/C++ Compile & Run:

1
$ g++ -std=c++20 main.cpp -o main

2 Types & Structs

2.1 Primitive Types

2.2 Structs

A struct is a group of named variables, each with their own type, that allows programmers to bundle different types together!

1
/* C++ Style */
2
struct Student {
3
    string name; // these are called fields
4
    string state; // separate these by semicolons
5
    int age;
6
};
7

8
/* C Style */
9
typedef struct {
10
    char name[50];
11
    char state[3];
12
    int age;
13
} Student;
14

15
Student s;
16
s.name = "Haven";
17
s.state = "AR";
18
s.age = 22; // use . to access fields

2.3 Union

Unions are similar to structs, but all members share the same memory location, and union only provides enough space for the largest element.

1
#include <iostream>
2

3
union Shape {
4
    int radius; // For circle
5
    struct {
6
        int width;
7
        int height;
8
    } rectangle; // For rectangle
9
};
10

11
int main() {
12
    Shape shape;
13
    shape.radius = 5;
14
    std::cout << "Radius: " << shape.radius << std::endl; // Radius: 5
15

16
    shape.rectangle.width = 10;
17
    shape.rectangle.height = 20;
18
    std::cout << "Width: " << shape.rectangle.width << ", Height: " << shape.rectangle.height << std::endl;
19
    // Width: 10, Height: 20
20

21
    std::cout << "Radius: " << shape.radius << std::endl;
22
    // No meaning, the radius has been overwritten!
23

24
    return 0;
25
}

2.4 Enum

An enumeration is a distinct type whose value is restricted to a range of values, which may include several explicitly named constants (“enumerators”).

For C and earlier versions of C++, you can declare enum. Since C++ 11, you can declare enum, enum class and enum struct. enum class and struct are strongly typed and create a namespace for its enumerators.

9 collapsed lines
1
enum Color {
2
    RED,
3
    GREEN,
4
    BLUE
5
};
6

7
Color myColor = GREEN;
8
int colorValue = myColor; // Implicit conversion - ok
9
// myColor = 5; // Error：a value of type "int" cannot be assigned to an entity of type "Color"

20 collapsed lines
1
// Using enum class
2
enum class Status1 {
3
    SUCCESS,
4
    PENDING,
5
    FAILED,
6
    ERROR
7
};
8

9
// Using enum struct (equivalent to enum class)
10
enum struct Status2 {
11
    OK,
12
    PROCESSING,
13
    ERROR
14
};
15

16
Status1 status1 = Status1::ERROR; // scoped enum
17
Status2 status2 = Status2::ERROR;
18

19
// int s = status1; // Error: a value of type "Status1" cannot be used to initialize an entity of type "int"
20
int s = static_cast<int>(status1); // Explicit conversion - ok

2.5 C++ Preprocessor Macros

Preprocessor macros are a way to define constants or perform text substitution in your code before compilation.

Example

1
# define PI 3.14159
2

3
int main() {
4
    double radius = 5.0;
5
    double area = PI * radius * radius;
6
    std::cout << "Area of the circle: " << area << std::endl;
7
    // Output: Area of the circle: 78.5397
8
    return 0;
9
}

3 Initialization & References

3.1 Initialization

There are three types of initialization in C++:

1. Direct Initialization

1
int numOne = 12.0; // numOne is 12, doesn't type check with direct initialzation

2. Uniform Initialization (C++ 11)

1
int numTwo {12.0};
2
// Narrowing conversion of '1.2e+1' from 'double' to 'int'
3
// Type checks with uniform initialization

3. Structure Binding (C++ 17, can access multiple values returned by a function)

1
#include <iostream>
2
#include <tuple>
3
#include <string>
4

5
std::tuple<std::string, std::string, std::string> getclassInfo() {
6
    std::string className = "CS106L";
7
    std::string buildingName = "Turing Auditorium";
8
    std::string language = "C++";
9
    return {className, buildingName, language};
10
}
11

12
int main() {
13
    auto [className, buildingName, language] = getclassInfo();
14

15
    std::cout << "Come to " << buildingName << " and join us for " <<
16
    className << " to learn " << language << "!" << std::endl;
17
    // Output: Come to Turing Auditorium and join us for CS106L to learn C++!
18

19
    return 0;
20
}

Advantages for Uniform Initialization

• It’s safe! It doesn’t allow for narrowing conversions — which can lead to unexpected behaviour (or critical system failures).
• It’s ubiquitous! it works for all types like vectors, maps, and custom classes, among other things.

3.2 References

1
int x = 5;
2
int& ref = x; // ref is a reference to x
3
ref = 10; // x is now 10

3.3 Pointers

1
int x = 5;
2
int* ref = &x; // ref is a pointer to x
3
*ref = 10; // x is now 10

A classic reference-copy bug:

1
// We are modifying the std::pair's inside of nums
2
void shift(std::vector<std::pair<int, int>> &nums) { // nums passed by reference
3
    for (auto [num1, num2] : nums) { // num1 and num2 are copies
4
        num1++;
5
        num2++;
6
    }
7
}

In this code, nums is passed by reference to the shift function, which means any modifications to nums should affect the original vector. However, within the for loop,num1 and num2 are declared as copies of the elements in nums. As a result, the increments num1++ and num2++ modify only the local copies, and the original elements in nums remain unchanged. Below is the correct way:

1
// Correct Way
2
void shift(std::vector<std::pair<int, int>> &nums) {
3
    for (auto& [num1, num2] : nums) {
4
        num1++;
5
        num2++;
6
    }
7
}

4 Streams

4.1 Strings

Example in C++

1
std::string str = "Hello, World!";
2
std::cout << str[1] << std::endl; // e
3
str[1] = 'a'; // Hallo, World!

Example in C

1
char str[] = "Hello, World!";
2
printf("%c\n", str[1]); // e
3
str[1] = 'a'; // Hallo, World!

4.2 Stringstreams

Properties

• Constructors with initial text in the buffer.
• Can optionally provide “modes” such as ate (start at end) or bin (read as binary).

4.2.1 Output Stringstreams

Examples

1
std::ostringstream oss("Ito-En Green Tea");
2
std::cout << oss.str() << std::endl; // Ito-En Green Tea
3
oss << "16.9 Ounces";
4
std::cout << oss.str() << std::endl; // 16.9 Ouncesn Tea
5

6
std::ostringstream oss("Ito-En Green Tea", std::ostringstream::ate);
7
oss << "16.9 Ounces";
8
std::cout << oss.str() << std::endl; // Ito-En Green Tea16.9 Ounces

Positioning functions in output stringstream include tellp() and seekp().

1. tellp(): Returns the current position of the put pointer in the output stringstream.

1
#include <iostream>
2
#include <sstream>
3

4
int main() {
5
    std::ostringstream oss;
6
    oss << "Hello";
7

8
    std::streampos currentPos = oss.tellp();
9
    std::cout << "Current put pointer position: " << currentPos << std::endl;
10
    // Output: 5
11

12
    oss << " World!";
13
    currentPos = oss.tellp();
14
    std::cout << "New put pointer position: " << currentPos << std::endl;
15
    // Output: 12
16

17
    return 0;
18
}

2. seekp(pos): Moves the put pointer to a specific position within the output stringstream.

The position can be an absolute offset from the beginning of the stream, or a relative offset from the current position (using std::ios::beg, std::ios::cur, or std::ios::end as a second argument).

33 collapsed lines
1
#include <iostream>
2
#include <sstream>
3

4
int main() {
5
    std::ostringstream oss;
6
    oss << "Hello World!";
7

8
    // 1. Absolute positioning (from the beginning)
9
    oss.seekp(0); // Move to the beginning
10
    oss << "Hi"; // Overwrite "He"
11

12
    std::cout << oss.str() << std::endl; // Output: Hillo World!
13

14
    // 2. Relative positioning (from the end)
15
    oss.seekp(-2, std::ios::end); // Move 2 positions back from the end
16
    oss << "???"; // Overwrite "d!"
17

18
    std::cout << oss.str() << std::endl; // Output: Hillo Worl???
19

20
    // 3. Using std::ios::beg (from the beginning)
21
    oss.seekp(5, std::ios::beg); // Move 5 positions from the beginning
22
    oss << "-"; // Insert "-"
23

24
    std::cout << oss.str() << std::endl; // Output: Hillo-Worl???
25

26
    // 4. Using std::ios::cur (from the current position)
27
    oss.seekp(2, std::ios::cur); // Move 2 positions forward from the current position
28
    oss << "+"; // Insert "+"
29

30
    std::cout << oss.str() << std::endl; // Output: Hillo-Wo+l???
31

32
    return 0;
33
}

4.2.2 Input Stringstreams

Example

1
std::istringstream iss("16.9 Ounces");
2
double amount;
3
std::string unit;
4
iss >> amount >> unit; // amount = 16.9, unit = "Ounces"
5

6
std::istringstream iss("16.9 Ounces");
7
int amount;
8
std::string unit;
9
iss >> amount >> unit; // amount = 16, unit = ".9"

Positioning functions in input stringstream include tellg() and seekg(), which are similar to output stringstream.

1. tellg()

18 collapsed lines
1
#include <iostream>
2
#include <sstream>
3

4
int main() {
5
    std::istringstream iss("Hello World");
6

7
    iss >> std::ws; // Skip leading whitespaces
8

9
    std::cout << "Current position: " << iss.tellg() << std::endl;
10
    // Output: 0
11

12
    std::string word;
13
    iss >> word; // Read "Hello"
14

15
    std::cout << "Current position: " << iss.tellg() << std::endl;
16
    // Output: 5
17

18
    return 0;
19
}

2. seekg(pos)

31 collapsed lines
1
#include <iostream>
2
#include <sstream>
3

4
int main() {
5
    std::istringstream iss("Hello World");
6

7
    iss.seekg(7);
8
    char char1;
9
    iss.get(char1);
10
    std::cout << "Character read: " << char1 << std::endl;
11
    // Output: o
12

13
    iss.seekg(6, std::ios::beg);
14
    std::string word1;
15
    iss >> word1;
16
    std::cout << "Word read: " << word1 << std::endl;
17
    // Output: World
18

19
    iss.seekg(-2, std::ios::cur);
20
    char char2;
21
    iss.get(char2);
22
    std::cout << "Character read: " << char2 << std::endl;
23
    // Output: d
24

25
    iss.seekg(-5, std::ios::end);
26
    std::string word2;
27
    iss >> word2;
28
    std::cout << "Word read: " << word2 << std::endl;
29
    // Output: World
30

31
    return 0;
32
}

There are two data types for positions in streams: std::streampos and std::streamoff.

• std::streampos: Represents the position of the get pointer.
• std::streamoff: Represents the difference (offset) between two streampos values.

Example

33 collapsed lines
1
#include <iostream>
2
#include <sstream>
3

4
int main() {
5
    std::ostringstream oss;
6
    oss << "Hello, world!";
7

8
    // Get the current position using streampos
9
    std::streampos pos = oss.tellp();
10
    std::cout << "Current position in output stream: " << pos << std::endl;
11
    // Outputs: 13
12

13
    // Move the position using streamoff
14
    oss.seekp(5, std::ios::beg);
15
    pos = oss.tellp();
16
    std::cout << "New position in output stream after seekp: " << pos << std::endl;
17
    // Outputs: 5
18

19
    // Create an input string stream with the data from the output stream
20
    std::istringstream iss(oss.str());
21

22
    // Get the current position using streampos
23
    pos = iss.tellg();
24
    std::cout << "Current position in input stream: " << pos << std::endl; //
25
    Outputs: 0
26

27
    // Move the position using streamoff
28
    iss.seekg(7, std::ios::beg);
29
    pos = iss.tellg();
30
    std::cout << "New position in input stream after seekg: " << pos <<
31
    std::endl; // Outputs: 7
32

33
    return 0;
34
}

4.2.3 Stringstreams

Example

1
#include <iostream>
2
#include <sstream>
3

4
int main() {
5
    std::stringstream ss("Hello, World!");
6
    std::string word;
7
    ss >> word;
8
    std::cout << word << std::endl; // Hello,
9

10
    ss << "CS106L";
11
    std::cout << ss.str() << std::endl; // Hello, World!CS106L
12

13
    return 0;
14
}

4.2.4 State Bits

1. Good Bit: Ready for read/write (nothing unusual, on when other bits are off).
2. Fail Bit: Previous operation failed, all future operations frozen (type mismatch, file can’t be opened, seekg failed, etc.).
3. EOF Bit: Previous operation reached the end of buffer content.
4. Bad Bit: External error, like irrecoverable (e.g., the file you are reading from suddenly is deleted).

Example

1
std::istringstream iss("17");
2
int amount;
3
iss >> amount;
4
std::cout << (iss.eof() ? "EOF" : "Not EOF") << std::endl;

4.3 iostreams

4.3.1 Input Streams

1. std::cin: Standard input stream.

• The position pointer skips whitespace after the token with each >> operator.
• The position pointer does the following:
  • consumes all whitespaces (spaces, newlines, ‘\t’, ‘\n’, etc.)
  • reads as many characters until:
    • a whitespace is reached
    • or, for primitives, the maximum number of bytes necessary to form a valid variable.

2. std::getline: Another input strean function. istream& getline(istream& is, string& str, char delim)

• getline() reads an input stream is, up until the delim char and stores it in some buffer str.
• The delim char is by default ‘\n’.
• getline() consumes the delim character!

Example:

15 collapsed lines
1
#include <iostream>
2
#include <string>
3

4
int main() {
5
    double pi;
6
    std::string name;
7
    std::cin >> pi;
8
    std::cin.ignore(); // ignore the newline character
9
    // std::getline(std::cin, name); // alternative way to ignore
10
    std::getline(std::cin, name);
11
    std::cin >> r;
12
    std::cout << "Hello, " << name << "!" << std::endl;
13
    std::cout << "Value of pi: " << pi << std::endl;
14
    return 0;
15
}

3. std::ifstream: Input file stream.

Example:

20 collapsed lines
1
#include <iostream>
2
#include <fstream>
3

4
int main() {
5
    std::ifstream file("input.txt");
6

7
    if (!file.is_open()) {
8
        std::cerr << "File not found!" << std::endl;
9
        return 1;
10
    }
11
    else {
12
        std::string line;
13
        while (std::getline(file, line)) {
14
            std::cout << line << std::endl;
15
        }
16
        file.close();
17
    }
18

19
    return 0;
20
}

4.3.2 Output Streams

1. std::cout: Standard output stream.
2. std::cerr: Standard error stream (unbuffered), used for displaying error messages and diagnostic information.
3. std::clog: Standard error stream (buffered), used for displaying logging information.
4. std::ofstream: Output file stream.

1
#include <iostream>
2

3
int main() {
4
    bool error = true;
5
    std::clog << "Starting program execution...\n";
6
    std::clog << "Processing data...\n";
7
    if (error) {
8
        std::cerr << "Error: Data processing failed!\n";
9
    }
10
    std::clog << "Program finished.\n";
11
    return 0;
12
}

Now if we execute the program with:

1
./outputStream 2> error.log

You can see the messages of std::cerr in the error.log file.