C++ Projects – Page 10 – Projects Inventory

Stack Implementation Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>

template<typename T>
class Stack {
public:
    Stack() : top(nullptr) {}

    ~Stack() {
        while (!isEmpty()) {
            pop();
        }
    }

    void push(const T& value) {
        Node* newNode = new Node(value);
        newNode->next = top;
        top = newNode;
        std::cout << value << " pushed to stack" << std::endl;
    }

    void pop() {
        if (isEmpty()) {
            std::cout << "Stack is empty. Nothing to pop." << std::endl;
            return;
        }
        Node* temp = top;
        top = top->next;
        std::cout << temp->data << " popped from stack" << std::endl;
        delete temp;
    }

    T peek() const {
        if (isEmpty()) {
            throw std::runtime_error("Stack is empty.");
        }
        return top->data;
    }

    bool isEmpty() const {
        return top == nullptr;
    }

    void display() const {
        Node* current = top;
        if (isEmpty()) {
            std::cout << "Stack is empty." << std::endl;
            return;
        }
        std::cout << "Stack elements:" << std::endl;
        while (current != nullptr) {
            std::cout << current->data << std::endl;
            current = current->next;
        }
    }

private:
    struct Node {
        T data;
        Node* next;
        Node(const T& value) : data(value), next(nullptr) {}
    };

    Node* top;
};

int main() {
    Stack<int> stack;

    stack.push(10);
    stack.push(20);
    stack.push(30);

    std::cout << "Top element is: " << stack.peek() << std::endl;

    stack.display();

    stack.pop();
    stack.pop();

    std::cout << "Top element is: " << stack.peek() << std::endl;

    stack.display();

    return 0;
}

#include <iostream>

template<typename T>

class Stack {

public:

Stack() : top(nullptr) {}

~Stack() {

while (!isEmpty()) {

pop();

}

void push(const T& value) {

Node* newNode = new Node(value);

newNode->next = top;

top = newNode;

std::cout << value << " pushed to stack" << std::endl;

}

void pop() {

if (isEmpty()) {

std::cout << "Stack is empty. Nothing to pop." << std::endl;

return;

}

Node* temp = top;

top = top->next;

std::cout << temp->data << " popped from stack" << std::endl;

delete temp;

}

T peek() const {

if (isEmpty()) {

throw std::runtime_error("Stack is empty.");

}

return top->data;

}

bool isEmpty() const {

return top == nullptr;

}

void display() const {

Node* current = top;

if (isEmpty()) {

std::cout << "Stack is empty." << std::endl;

return;

}

std::cout << "Stack elements:" << std::endl;

while (current != nullptr) {

std::cout << current->data << std::endl;

current = current->next;

}

private:

struct Node {

T data;

Node* next;

Node(const T& value) : data(value), next(nullptr) {}

};

Node* top;

};

int main() {

Stack<int> stack;

stack.push(10);

stack.push(20);

stack.push(30);

std::cout << "Top element is: " << stack.peek() << std::endl;

stack.display();

stack.pop();

std::cout << "Top element is: " << stack.peek() << std::endl;

stack.display();

return 0;

}

Explanation: Stack Class: Attributes: top: Pointer to the top node in the stack. Nested Node Structure: data: Stores the value of the node. next: Pointer to the next node in the stack. Methods: Stack(): Constructor initializes an empty stack. ~Stack(): Destructor deletes all nodes to free memory. push(const T& value): Adds a new element …

Stack Implementation Gaming Project in C++ Read More »

Stopwatch Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <chrono>
#include <thread>
#include <iomanip>

class Stopwatch {
public:
    Stopwatch() : startTime(), endTime(), running(false), elapsedTime(0) {}

    void start() {
        if (!running) {
            startTime = std::chrono::high_resolution_clock::now();
            running = true;
            std::cout << "Stopwatch started!" << std::endl;
        } else {
            std::cout << "Stopwatch is already running!" << std::endl;
        }
    }

    void stop() {
        if (running) {
            endTime = std::chrono::high_resolution_clock::now();
            elapsedTime += std::chrono::duration<double>(endTime - startTime).count();
            running = false;
            std::cout << "Stopwatch stopped!" << std::endl;
        } else {
            std::cout << "Stopwatch is not running!" << std::endl;
        }
    }

    void reset() {
        if (running) {
            startTime = std::chrono::high_resolution_clock::now();
        } else {
            elapsedTime = 0;
        }
        std::cout << "Stopwatch reset!" << std::endl;
    }

    void display() const {
        double currentTime = elapsedTime;
        if (running) {
            auto now = std::chrono::high_resolution_clock::now();
            currentTime += std::chrono::duration<double>(now - startTime).count();
        }
        int minutes = static_cast<int>(currentTime) / 60;
        int seconds = static_cast<int>(currentTime) % 60;
        int milliseconds = static_cast<int>((currentTime - static_cast<int>(currentTime)) * 1000);

        std::cout << "Elapsed Time: " 
                  << std::setw(2) << std::setfill('0') << minutes << ":"
                  << std::setw(2) << std::setfill('0') << seconds << "."
                  << std::setw(3) << std::setfill('0') << milliseconds 
                  << std::endl;
    }

private:
    std::chrono::high_resolution_clock::time_point startTime;
    std::chrono::high_resolution_clock::time_point endTime;
    bool running;
    double elapsedTime;
};

int main() {
    Stopwatch stopwatch;
    char command;

    while (true) {
        std::cout << "Enter command (s: start, t: stop, r: reset, d: display, q: quit): ";
        std::cin >> command;

        switch (command) {
            case 's':
                stopwatch.start();
                break;
            case 't':
                stopwatch.stop();
                break;
            case 'r':
                stopwatch.reset();
                break;
            case 'd':
                stopwatch.display();
                break;
            case 'q':
                std::cout << "Quitting..." << std::endl;
                return 0;
            default:
                std::cout << "Invalid command!" << std::endl;
                break;
        }
    }

    return 0;
}

#include <iostream>

#include <chrono>

#include <thread>

#include <iomanip>

class Stopwatch {

public:

Stopwatch() : startTime(), endTime(), running(false), elapsedTime(0) {}

void start() {

if (!running) {

startTime = std::chrono::high_resolution_clock::now();

running = true;

std::cout << "Stopwatch started!" << std::endl;

} else {

std::cout << "Stopwatch is already running!" << std::endl;

}

void stop() {

if (running) {

endTime = std::chrono::high_resolution_clock::now();

elapsedTime += std::chrono::duration<double>(endTime - startTime).count();

running = false;

std::cout << "Stopwatch stopped!" << std::endl;

} else {

std::cout << "Stopwatch is not running!" << std::endl;

}

void reset() {

if (running) {

startTime = std::chrono::high_resolution_clock::now();

} else {

elapsedTime = 0;

}

std::cout << "Stopwatch reset!" << std::endl;

}

void display() const {

double currentTime = elapsedTime;

if (running) {

auto now = std::chrono::high_resolution_clock::now();

currentTime += std::chrono::duration<double>(now - startTime).count();

}

int minutes = static_cast<int>(currentTime) / 60;

int seconds = static_cast<int>(currentTime) % 60;

int milliseconds = static_cast<int>((currentTime - static_cast<int>(currentTime)) * 1000);

std::cout << "Elapsed Time: "

<< std::setw(2) << std::setfill('0') << minutes << ":"

<< std::setw(2) << std::setfill('0') << seconds << "."

<< std::setw(3) << std::setfill('0') << milliseconds

<< std::endl;

}

private:

std::chrono::high_resolution_clock::time_point startTime;

std::chrono::high_resolution_clock::time_point endTime;

bool running;

double elapsedTime;

};

int main() {

Stopwatch stopwatch;

char command;

while (true) {

std::cout << "Enter command (s: start, t: stop, r: reset, d: display, q: quit): ";

std::cin >> command;

switch (command) {

case 's':

stopwatch.start();

break;

case 't':

stopwatch.stop();

break;

case 'r':

stopwatch.reset();

break;

case 'd':

stopwatch.display();

break;

case 'q':

std::cout << "Quitting..." << std::endl;

return 0;

default:

std::cout << "Invalid command!" << std::endl;

break;

}

return 0;

}

Explanation: Stopwatch Class: Attributes: startTime: Marks the time when the stopwatch starts. endTime: Marks the time when the stopwatch stops. running: Indicates whether the stopwatch is currently running. elapsedTime: Holds the total elapsed time in seconds. Methods: start(): Starts the stopwatch by recording the current time if it’s not already running. stop(): Stops the …

Stopwatch Gaming Project in C++ Read More »

Student Database Management System Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <unordered_map>
#include <string>

class Student {
public:
    Student(const std::string& name, int age) : name(name), age(age) {}

    void display() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }

private:
    std::string name;
    int age;
};

class StudentDatabase {
public:
    void addStudent(const std::string& id, const std::string& name, int age) {
        if (students.find(id) == students.end()) {
            students[id] = Student(name, age);
            std::cout << "Student added: " << name << std::endl;
        } else {
            std::cout << "Student ID already exists!" << std::endl;
        }
    }

    void viewStudent(const std::string& id) const {
        if (students.find(id) != students.end()) {
            students.at(id).display();
        } else {
            std::cout << "Student ID not found!" << std::endl;
        }
    }

    void deleteStudent(const std::string& id) {
        if (students.find(id) != students.end()) {
            students.erase(id);
            std::cout << "Student ID " << id << " deleted." << std::endl;
        } else {
            std::cout << "Student ID not found!" << std::endl;
        }
    }

private:
    std::unordered_map<std::string, Student> students;
};

int main() {
    StudentDatabase db;

    // Adding students
    db.addStudent("1001", "Alice Johnson", 20);
    db.addStudent("1002", "Bob Smith", 22);

    // Viewing student details
    db.viewStudent("1001");
    db.viewStudent("1002");

    // Deleting a student
    db.deleteStudent("1001");

    // Attempting to view deleted student
    db.viewStudent("1001");

    return 0;
}

#include <iostream>

#include <unordered_map>

#include <string>

class Student {

public:

Student(const std::string& name, int age) : name(name), age(age) {}

void display() const {

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

}

private:

std::string name;

int age;

};

class StudentDatabase {

public:

void addStudent(const std::string& id, const std::string& name, int age) {

if (students.find(id) == students.end()) {

students[id] = Student(name, age);

std::cout << "Student added: " << name << std::endl;

} else {

std::cout << "Student ID already exists!" << std::endl;

}

void viewStudent(const std::string& id) const {

if (students.find(id) != students.end()) {

students.at(id).display();

} else {

std::cout << "Student ID not found!" << std::endl;

}

void deleteStudent(const std::string& id) {

if (students.find(id) != students.end()) {

students.erase(id);

std::cout << "Student ID " << id << " deleted." << std::endl;

} else {

std::cout << "Student ID not found!" << std::endl;

}

private:

std::unordered_map<std::string, Student> students;

};

int main() {

StudentDatabase db;

// Adding students

db.addStudent("1001", "Alice Johnson", 20);

db.addStudent("1002", "Bob Smith", 22);

// Viewing student details

db.viewStudent("1001");

db.viewStudent("1002");

// Deleting a student

db.deleteStudent("1001");

// Attempting to view deleted student

db.viewStudent("1001");

return 0;

}

Explanation: Student Class: Represents a student with name and age. display() const: Displays the student’s details. StudentDatabase Class: Manages student records using an unordered map (std::unordered_map). addStudent(const std::string& id, const std::string& name, int age): Adds a new student if the ID does not already exist. viewStudent(const std::string& id) const: Displays the details of a …

Student Database Management System Gaming Project in C++ Read More »

Sudoku Solver Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>

const int SIZE = 9; // Size of the Sudoku grid

// Function to print the Sudoku grid
void printGrid(const std::vector<std::vector<int>>& grid) {
    for (const auto& row : grid) {
        for (int num : row) {
            std::cout << num << ' ';
        }
        std::cout << std::endl;
    }
}

// Function to check if placing num at grid[row][col] is valid
bool isValid(const std::vector<std::vector<int>>& grid, int row, int col, int num) {
    // Check row
    for (int c = 0; c < SIZE; ++c) {
        if (grid[row][c] == num) return false;
    }

    // Check column
    for (int r = 0; r < SIZE; ++r) {
        if (grid[r][col] == num) return false;
    }

    // Check 3x3 subgrid
    int startRow = row - row % 3;
    int startCol = col - col % 3;
    for (int r = startRow; r < startRow + 3; ++r) {
        for (int c = startCol; c < startCol + 3; ++c) {
            if (grid[r][c] == num) return false;
        }
    }

    return true;
}

// Backtracking function to solve the Sudoku
bool solveSudoku(std::vector<std::vector<int>>& grid) {
    for (int row = 0; row < SIZE; ++row) {
        for (int col = 0; col < SIZE; ++col) {
            if (grid[row][col] == 0) { // Find an empty cell
                for (int num = 1; num <= SIZE; ++num) {
                    if (isValid(grid, row, col, num)) {
                        grid[row][col] = num;
                        if (solveSudoku(grid)) return true;
                        grid[row][col] = 0; // Backtrack
                    }
                }
                return false; // Trigger backtracking
            }
        }
    }
    return true; // All cells are filled
}

int main() {
    // Example Sudoku grid (0 represents empty cells)
    std::vector<std::vector<int>> grid = {
        {5, 3, 0, 0, 7, 0, 0, 0, 0},
        {6, 0, 0, 1, 9, 5, 0, 0, 0},
        {0, 9, 8, 0, 0, 0, 0, 6, 0},
        {8, 0, 0, 0, 6, 0, 0, 0, 3},
        {4, 0, 0, 8, 0, 3, 0, 0, 1},
        {7, 0, 0, 0, 2, 0, 0, 0, 6},
        {0, 6, 0, 0, 0, 0, 2, 8, 0},
        {0, 0, 0, 4, 1, 9, 0, 0, 5},
        {0, 0, 0, 0, 8, 0, 0, 7, 9}
    };

    if (solveSudoku(grid)) {
        std::cout << "Sudoku solved successfully!" << std::endl;
        printGrid(grid);
    } else {
        std::cout << "No solution exists!" << std::endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

const int SIZE = 9; // Size of the Sudoku grid

// Function to print the Sudoku grid

void printGrid(const std::vector<std::vector<int>>& grid) {

for (const auto& row : grid) {

for (int num : row) {

std::cout << num << ' ';

}

std::cout << std::endl;

}

// Function to check if placing num at grid[row][col] is valid

bool isValid(const std::vector<std::vector<int>>& grid, int row, int col, int num) {

// Check row

for (int c = 0; c < SIZE; ++c) {

if (grid[row][c] == num) return false;

}

// Check column

for (int r = 0; r < SIZE; ++r) {

if (grid[r][col] == num) return false;

}

// Check 3x3 subgrid

int startRow = row - row % 3;

int startCol = col - col % 3;

for (int r = startRow; r < startRow + 3; ++r) {

for (int c = startCol; c < startCol + 3; ++c) {

if (grid[r][c] == num) return false;

}

return true;

}

// Backtracking function to solve the Sudoku

bool solveSudoku(std::vector<std::vector<int>>& grid) {

for (int row = 0; row < SIZE; ++row) {

for (int col = 0; col < SIZE; ++col) {

if (grid[row][col] == 0) { // Find an empty cell

for (int num = 1; num <= SIZE; ++num) {

if (isValid(grid, row, col, num)) {

grid[row][col] = num;

if (solveSudoku(grid)) return true;

grid[row][col] = 0; // Backtrack

}

return false; // Trigger backtracking

}

return true; // All cells are filled

}

int main() {

// Example Sudoku grid (0 represents empty cells)

std::vector<std::vector<int>> grid = {

{5, 3, 0, 0, 7, 0, 0, 0, 0},

{6, 0, 0, 1, 9, 5, 0, 0, 0},

{0, 9, 8, 0, 0, 0, 0, 6, 0},

{8, 0, 0, 0, 6, 0, 0, 0, 3},

{4, 0, 0, 8, 0, 3, 0, 0, 1},

{7, 0, 0, 0, 2, 0, 0, 0, 6},

{0, 6, 0, 0, 0, 0, 2, 8, 0},

{0, 0, 0, 4, 1, 9, 0, 0, 5},

{0, 0, 0, 0, 8, 0, 0, 7, 9}

};

if (solveSudoku(grid)) {

std::cout << "Sudoku solved successfully!" << std::endl;

printGrid(grid);

} else {

std::cout << "No solution exists!" << std::endl;

}

return 0;

}

Explanation: Constants: SIZE: Defines the size of the Sudoku grid (9×9). printGrid Function: Prints the Sudoku grid to the console, showing numbers and spaces. isValid Function: Checks if placing a number in a specific cell is valid: Row Check: Ensures the number is not already in the same row. Column Check: Ensures the number …

Sudoku Solver Gaming Project in C++ Read More »

Simulation of Customer Relationship Management Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <unordered_map>
#include <string>

class Customer {
public:
    Customer(const std::string& name, const std::string& email) 
        : name(name), email(email) {}

    void updateEmail(const std::string& newEmail) {
        email = newEmail;
    }

    void display() const {
        std::cout << "Name: " << name << ", Email: " << email << std::endl;
    }

private:
    std::string name;
    std::string email;
};

class CRMSystem {
public:
    void addCustomer(const std::string& id, const std::string& name, const std::string& email) {
        if (customers.find(id) == customers.end()) {
            customers[id] = Customer(name, email);
            std::cout << "Customer added: " << name << std::endl;
        } else {
            std::cout << "Customer ID already exists!" << std::endl;
        }
    }

    void updateCustomerEmail(const std::string& id, const std::string& newEmail) {
        if (customers.find(id) != customers.end()) {
            customers[id].updateEmail(newEmail);
            std::cout << "Email updated for Customer ID: " << id << std::endl;
        } else {
            std::cout << "Customer ID not found!" << std::endl;
        }
    }

    void viewCustomer(const std::string& id) const {
        if (customers.find(id) != customers.end()) {
            customers.at(id).display();
        } else {
            std::cout << "Customer ID not found!" << std::endl;
        }
    }

private:
    std::unordered_map<std::string, Customer> customers;
};

int main() {
    CRMSystem crm;

    // Adding customers
    crm.addCustomer("001", "Alice Johnson", "alice@example.com");
    crm.addCustomer("002", "Bob Smith", "bob@example.com");

    // Viewing customer details
    crm.viewCustomer("001");
    crm.viewCustomer("002");

    // Updating email
    crm.updateCustomerEmail("001", "alice.johnson@example.com");

    // Viewing updated details
    crm.viewCustomer("001");

    return 0;
}

#include <iostream>

#include <unordered_map>

#include <string>

class Customer {

public:

Customer(const std::string& name, const std::string& email)

: name(name), email(email) {}

void updateEmail(const std::string& newEmail) {

email = newEmail;

}

void display() const {

std::cout << "Name: " << name << ", Email: " << email << std::endl;

}

private:

std::string name;

std::string email;

};

class CRMSystem {

public:

void addCustomer(const std::string& id, const std::string& name, const std::string& email) {

if (customers.find(id) == customers.end()) {

customers[id] = Customer(name, email);

std::cout << "Customer added: " << name << std::endl;

} else {

std::cout << "Customer ID already exists!" << std::endl;

}

void updateCustomerEmail(const std::string& id, const std::string& newEmail) {

if (customers.find(id) != customers.end()) {

customers[id].updateEmail(newEmail);

std::cout << "Email updated for Customer ID: " << id << std::endl;

} else {

std::cout << "Customer ID not found!" << std::endl;

}

void viewCustomer(const std::string& id) const {

if (customers.find(id) != customers.end()) {

customers.at(id).display();

} else {

std::cout << "Customer ID not found!" << std::endl;

}

private:

std::unordered_map<std::string, Customer> customers;

};

int main() {

CRMSystem crm;

// Adding customers

crm.addCustomer("001", "Alice Johnson", "alice@example.com");

crm.addCustomer("002", "Bob Smith", "bob@example.com");

// Viewing customer details

crm.viewCustomer("001");

crm.viewCustomer("002");

// Updating email

crm.updateCustomerEmail("001", "alice.johnson@example.com");

// Viewing updated details

crm.viewCustomer("001");

return 0;

}

Explanation: Customer Class: Represents a customer with name and email. updateEmail(const std::string& newEmail): Updates the customer’s email address. display() const: Displays the customer’s details. CRMSystem Class: Manages multiple customers using an unordered map (std::unordered_map). addCustomer(const std::string& id, const std::string& name, const std::string& email): Adds a new customer if the ID does not already exist. …

Simulation of Customer Relationship Management Gaming Project in C++ Read More »

Simulation of Cryptocurrency Transactions Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <unordered_map>
#include <string>

class User {
public:
    User(const std::string& name) : name(name), balance(0.0) {}

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            std::cout << amount << " deposited. New balance: " << balance << std::endl;
        } else {
            std::cout << "Invalid deposit amount!" << std::endl;
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            std::cout << amount << " withdrawn. New balance: " << balance << std::endl;
        } else {
            std::cout << "Invalid withdrawal amount or insufficient funds!" << std::endl;
        }
    }

    double getBalance() const {
        return balance;
    }

private:
    std::string name;
    double balance;
};

class CryptocurrencySystem {
public:
    void addUser(const std::string& name) {
        if (users.find(name) == users.end()) {
            users[name] = User(name);
            std::cout << "User " << name << " added." << std::endl;
        } else {
            std::cout << "User already exists!" << std::endl;
        }
    }

    void deposit(const std::string& name, double amount) {
        if (users.find(name) != users.end()) {
            users[name].deposit(amount);
        } else {
            std::cout << "User not found!" << std::endl;
        }
    }

    void withdraw(const std::string& name, double amount) {
        if (users.find(name) != users.end()) {
            users[name].withdraw(amount);
        } else {
            std::cout << "User not found!" << std::endl;
        }
    }

    void checkBalance(const std::string& name) const {
        if (users.find(name) != users.end()) {
            std::cout << "Balance for " << name << ": " << users.at(name).getBalance() << std::endl;
        } else {
            std::cout << "User not found!" << std::endl;
        }
    }

private:
    std::unordered_map<std::string, User> users;
};

int main() {
    CryptocurrencySystem system;

    // Adding users
    system.addUser("Alice");
    system.addUser("Bob");

    // Performing transactions
    system.deposit("Alice", 100.0);
    system.deposit("Bob", 50.0);

    system.withdraw("Alice", 30.0);
    system.withdraw("Bob", 10.0);

    // Checking balances
    system.checkBalance("Alice");
    system.checkBalance("Bob");

    return 0;
}

#include <iostream>

#include <unordered_map>

#include <string>

class User {

public:

User(const std::string& name) : name(name), balance(0.0) {}

void deposit(double amount) {

if (amount > 0) {

balance += amount;

std::cout << amount << " deposited. New balance: " << balance << std::endl;

} else {

std::cout << "Invalid deposit amount!" << std::endl;

}

void withdraw(double amount) {

if (amount > 0 && amount <= balance) {

balance -= amount;

std::cout << amount << " withdrawn. New balance: " << balance << std::endl;

} else {

std::cout << "Invalid withdrawal amount or insufficient funds!" << std::endl;

}

double getBalance() const {

return balance;

}

private:

std::string name;

double balance;

};

class CryptocurrencySystem {

public:

void addUser(const std::string& name) {

if (users.find(name) == users.end()) {

users[name] = User(name);

std::cout << "User " << name << " added." << std::endl;

} else {

std::cout << "User already exists!" << std::endl;

}

void deposit(const std::string& name, double amount) {

if (users.find(name) != users.end()) {

users[name].deposit(amount);

} else {

std::cout << "User not found!" << std::endl;

}

void withdraw(const std::string& name, double amount) {

if (users.find(name) != users.end()) {

users[name].withdraw(amount);

} else {

std::cout << "User not found!" << std::endl;

}

void checkBalance(const std::string& name) const {

if (users.find(name) != users.end()) {

std::cout << "Balance for " << name << ": " << users.at(name).getBalance() << std::endl;

} else {

std::cout << "User not found!" << std::endl;

}

private:

std::unordered_map<std::string, User> users;

};

int main() {

CryptocurrencySystem system;

// Adding users

system.addUser("Alice");

system.addUser("Bob");

// Performing transactions

system.deposit("Alice", 100.0);

system.deposit("Bob", 50.0);

system.withdraw("Alice", 30.0);

system.withdraw("Bob", 10.0);

// Checking balances

system.checkBalance("Alice");

system.checkBalance("Bob");

return 0;

}

Explanation: User Class: Represents a user with a name and balance. deposit(double amount): Adds the specified amount to the user’s balance if it is positive. withdraw(double amount): Subtracts the specified amount from the user’s balance if it is positive and less than or equal to the current balance. getBalance(): Returns the current balance of …

Simulation of Cryptocurrency Transactions Gaming Project in C++ Read More »

Simulation of CPU Scheduling Algorithms Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <algorithm>

struct Process {
    int id;
    int arrivalTime;
    int burstTime;
    int waitingTime;
    int turnaroundTime;
};

// Function to calculate waiting time and turnaround time for FCFS
void calculateFCFS(std::vector<Process>& processes) {
    int n = processes.size();
    processes[0].waitingTime = 0; // First process has no waiting time
    processes[0].turnaroundTime = processes[0].burstTime;

    for (int i = 1; i < n; ++i) {
        processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;
        processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;
    }
}

// Function to calculate waiting time and turnaround time for SJF
void calculateSJF(std::vector<Process>& processes) {
    int n = processes.size();
    std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {
        return a.burstTime < b.burstTime;
    });

    processes[0].waitingTime = 0;
    processes[0].turnaroundTime = processes[0].burstTime;

    for (int i = 1; i < n; ++i) {
        processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;
        processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;
    }
}

// Function to print the process details
void printProcessDetails(const std::vector<Process>& processes, const std::string& algorithm) {
    std::cout << algorithm << " Scheduling\n";
    std::cout << "ID\tArrival\tBurst\tWaiting\tTurnaround\n";
    for (const auto& p : processes) {
        std::cout << p.id << '\t' << p.arrivalTime << '\t' << p.burstTime << '\t'
                  << p.waitingTime << '\t' << p.turnaroundTime << '\n';
    }
    std::cout << std::endl;
}

int main() {
    std::vector<Process> processes = {
        {1, 0, 8, 0, 0},
        {2, 1, 4, 0, 0},
        {3, 2, 9, 0, 0},
        {4, 3, 5, 0, 0}
    };

    // FCFS Scheduling
    std::vector<Process> fcfsProcesses = processes;
    calculateFCFS(fcfsProcesses);
    printProcessDetails(fcfsProcesses, "FCFS");

    // SJF Scheduling
    std::vector<Process> sjfProcesses = processes;
    calculateSJF(sjfProcesses);
    printProcessDetails(sjfProcesses, "SJF");

    return 0;
}

#include <iostream>

#include <vector>

#include <algorithm>

struct Process {

int id;

int arrivalTime;

int burstTime;

int waitingTime;

int turnaroundTime;

};

// Function to calculate waiting time and turnaround time for FCFS

void calculateFCFS(std::vector<Process>& processes) {

int n = processes.size();

processes[0].waitingTime = 0; // First process has no waiting time

processes[0].turnaroundTime = processes[0].burstTime;

for (int i = 1; i < n; ++i) {

processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;

processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;

}

// Function to calculate waiting time and turnaround time for SJF

void calculateSJF(std::vector<Process>& processes) {

int n = processes.size();

std::sort(processes.begin(), processes.end(), [](const Process& a, const Process& b) {

return a.burstTime < b.burstTime;

});

processes[0].waitingTime = 0;

processes[0].turnaroundTime = processes[0].burstTime;

for (int i = 1; i < n; ++i) {

processes[i].waitingTime = processes[i-1].waitingTime + processes[i-1].burstTime;

processes[i].turnaroundTime = processes[i].waitingTime + processes[i].burstTime;

}

// Function to print the process details

void printProcessDetails(const std::vector<Process>& processes, const std::string& algorithm) {

std::cout << algorithm << " Scheduling\n";

std::cout << "ID\tArrival\tBurst\tWaiting\tTurnaround\n";

for (const auto& p : processes) {

std::cout << p.id << '\t' << p.arrivalTime << '\t' << p.burstTime << '\t'

<< p.waitingTime << '\t' << p.turnaroundTime << '\n';

}

std::cout << std::endl;

}

int main() {

std::vector<Process> processes = {

{1, 0, 8, 0, 0},

{2, 1, 4, 0, 0},

{3, 2, 9, 0, 0},

{4, 3, 5, 0, 0}

};

// FCFS Scheduling

std::vector<Process> fcfsProcesses = processes;

calculateFCFS(fcfsProcesses);

printProcessDetails(fcfsProcesses, "FCFS");

// SJF Scheduling

std::vector<Process> sjfProcesses = processes;

calculateSJF(sjfProcesses);

printProcessDetails(sjfProcesses, "SJF");

return 0;

}

Explanation: Process Structure: Contains process details: id, arrivalTime, burstTime, waitingTime, and turnaroundTime. calculateFCFS Function: Calculates waiting and turnaround times for the First-Come, First-Served scheduling. The first process has zero waiting time, and each subsequent process waits for the previous one to complete. calculateSJF Function: Calculates waiting and turnaround times for the Shortest Job First …

Simulation of CPU Scheduling Algorithms Gaming Project in C++ Read More »

Simulation of Conway’s Game of Life Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

#include <iostream>
#include <vector>
#include <unistd.h> // for sleep()

const int WIDTH = 10;
const int HEIGHT = 10;

// Function to print the grid
void printGrid(const std::vector<std::vector<int>>& grid) {
    for (const auto& row : grid) {
        for (int cell : row) {
            std::cout << (cell ? '*' : '.') << ' ';
        }
        std::cout << std::endl;
    }
}

// Function to get the number of alive neighbors
int countAliveNeighbors(const std::vector<std::vector<int>>& grid, int x, int y) {
    const int directions[8][2] = {
        {-1, -1}, {-1, 0}, {-1, 1},
        {0, -1},         {0, 1},
        {1, -1}, {1, 0}, {1, 1}
    };

    int count = 0;
    for (const auto& dir : directions) {
        int nx = x + dir[0];
        int ny = y + dir[1];
        if (nx >= 0 && nx < WIDTH && ny >= 0 && ny < HEIGHT) {
            count += grid[nx][ny];
        }
    }
    return count;
}

// Function to update the grid based on Conway's rules
void updateGrid(std::vector<std::vector<int>>& grid) {
    std::vector<std::vector<int>> newGrid = grid;
    
    for (int x = 0; x < WIDTH; ++x) {
        for (int y = 0; y < HEIGHT; ++y) {
            int aliveNeighbors = countAliveNeighbors(grid, x, y);
            if (grid[x][y] == 1) {
                if (aliveNeighbors < 2 || aliveNeighbors > 3) {
                    newGrid[x][y] = 0; // Cell dies
                }
            } else {
                if (aliveNeighbors == 3) {
                    newGrid[x][y] = 1; // Cell becomes alive
                }
            }
        }
    }
    grid = newGrid;
}

int main() {
    // Initialize the grid with a glider pattern
    std::vector<std::vector<int>> grid(HEIGHT, std::vector<int>(WIDTH, 0));
    grid[1][2] = grid[2][3] = grid[3][1] = grid[3][2] = grid[3][3] = 1;

    // Number of iterations
    int iterations = 10;
    
    // Simulation loop
    for (int i = 0; i < iterations; ++i) {
        std::cout << "Generation " << i + 1 << std::endl;
        printGrid(grid);
        updateGrid(grid);
        sleep(1); // Pause for a second
        std::cout << std::endl;
    }

    return 0;
}

#include <iostream>

#include <vector>

#include <unistd.h> // for sleep()

const int WIDTH = 10;

const int HEIGHT = 10;

// Function to print the grid

void printGrid(const std::vector<std::vector<int>>& grid) {

for (const auto& row : grid) {

for (int cell : row) {

std::cout << (cell ? '*' : '.') << ' ';

}

std::cout << std::endl;

}

// Function to get the number of alive neighbors

int countAliveNeighbors(const std::vector<std::vector<int>>& grid, int x, int y) {

const int directions[8][2] = {

{-1, -1}, {-1, 0}, {-1, 1},

{0, -1}, {0, 1},

{1, -1}, {1, 0}, {1, 1}

};

int count = 0;

for (const auto& dir : directions) {

int nx = x + dir[0];

int ny = y + dir[1];

if (nx >= 0 && nx < WIDTH && ny >= 0 && ny < HEIGHT) {

count += grid[nx][ny];

}

return count;

}

// Function to update the grid based on Conway's rules

void updateGrid(std::vector<std::vector<int>>& grid) {

std::vector<std::vector<int>> newGrid = grid;

for (int x = 0; x < WIDTH; ++x) {

for (int y = 0; y < HEIGHT; ++y) {

int aliveNeighbors = countAliveNeighbors(grid, x, y);

if (grid[x][y] == 1) {

if (aliveNeighbors < 2 || aliveNeighbors > 3) {

newGrid[x][y] = 0; // Cell dies

}

} else {

if (aliveNeighbors == 3) {

newGrid[x][y] = 1; // Cell becomes alive

}

grid = newGrid;

}

int main() {

// Initialize the grid with a glider pattern

std::vector<std::vector<int>> grid(HEIGHT, std::vector<int>(WIDTH, 0));

grid[1][2] = grid[2][3] = grid[3][1] = grid[3][2] = grid[3][3] = 1;

// Number of iterations

int iterations = 10;

// Simulation loop

for (int i = 0; i < iterations; ++i) {

std::cout << "Generation " << i + 1 << std::endl;

printGrid(grid);

updateGrid(grid);

sleep(1); // Pause for a second

std::cout << std::endl;

}

return 0;

}

Explanation: Constants: WIDTH and HEIGHT: Dimensions of the grid. printGrid Function: Prints the grid to the console, where * represents an alive cell and . represents a dead cell. countAliveNeighbors Function: Calculates the number of alive neighbors for a cell at position (x, y). It checks all eight possible directions around the cell. updateGrid …

Simulation of Conway’s Game of Life Gaming Project in C++ Read More »

Simulation of Computer Vision Algorithms Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

Requirements: Install OpenCV library. For example, on Ubuntu, you can use: sudo apt-get install libopencv-dev. C++ Program (edge_detection.cpp)

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    // Load the grayscale image
    cv::Mat image = cv::imread("input.png", cv::IMREAD_GRAYSCALE);
    if (image.empty()) {
        std::cerr << "Error loading image!" << std::endl;
        return -1;
    }

    // Create matrices for the Sobel X and Y gradients
    cv::Mat gradX, gradY;
    cv::Mat absGradX, absGradY;
    cv::Mat edges;

    // Compute the Sobel X and Y gradients
    cv::Sobel(image, gradX, CV_16S, 1, 0, 3);
    cv::Sobel(image, gradY, CV_16S, 0, 1, 3);

    // Convert gradients to absolute values
    cv::convertScaleAbs(gradX, absGradX);
    cv::convertScaleAbs(gradY, absGradY);

    // Combine the gradients to get the edge magnitude
    cv::addWeighted(absGradX, 0.5, absGradY, 0.5, 0, edges);

    // Display the results
    cv::imshow("Original Image", image);
    cv::imshow("Sobel Edges", edges);

    // Wait for a key press and exit
    cv::waitKey(0);

    return 0;
}

#include <opencv2/opencv.hpp>

#include <iostream>

int main() {

// Load the grayscale image

cv::Mat image = cv::imread("input.png", cv::IMREAD_GRAYSCALE);

if (image.empty()) {

std::cerr << "Error loading image!" << std::endl;

return -1;

}

// Create matrices for the Sobel X and Y gradients

cv::Mat gradX, gradY;

cv::Mat absGradX, absGradY;

cv::Mat edges;

// Compute the Sobel X and Y gradients

cv::Sobel(image, gradX, CV_16S, 1, 0, 3);

cv::Sobel(image, gradY, CV_16S, 0, 1, 3);

// Convert gradients to absolute values

cv::convertScaleAbs(gradX, absGradX);

cv::convertScaleAbs(gradY, absGradY);

// Combine the gradients to get the edge magnitude

cv::addWeighted(absGradX, 0.5, absGradY, 0.5, 0, edges);

// Display the results

cv::imshow("Original Image", image);

cv::imshow("Sobel Edges", edges);

// Wait for a key press and exit

cv::waitKey(0);

return 0;

}

Explanation: Include OpenCV Headers: #include <opencv2/opencv.hpp>: Includes the necessary OpenCV headers. Load Image: cv::Mat image = cv::imread(“input.png”, cv::IMREAD_GRAYSCALE);: Loads an image in grayscale mode. Replace “input.png” with the path to your image file. Compute Gradients: cv::Mat …

Simulation of Computer Vision Algorithms Gaming Project in C++ Read More »

Simulation of Computer Networking Protocols Gaming Project in C++

Leave a Comment / C++ Projects / By Projects Inventory

Server Program (server.cpp)

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>

const int PORT = 8080;
const int BUFFER_SIZE = 1024;

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};
    const char* response = "Message received";

    // Creating socket file descriptor
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // Bind the socket
    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
        std::cerr << "Bind failed" << std::endl;
        return -1;
    }

    // Listen for incoming connections
    if (listen(server_fd, 3) < 0) {
        std::cerr << "Listen failed" << std::endl;
        return -1;
    }

    // Accept a connection
    if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) < 0) {
        std::cerr << "Accept failed" << std::endl;
        return -1;
    }

    // Read message from client
    read(new_socket, buffer, BUFFER_SIZE);
    std::cout << "Received: " << buffer << std::endl;

    // Send response to client
    send(new_socket, response, strlen(response), 0);
    std::cout << "Response sent" << std::endl;

    // Close sockets
    close(new_socket);
    close(server_fd);

    return 0;
}

#include <iostream>

#include <sys/socket.h>

#include <netinet/in.h>

#include <unistd.h>

#include <cstring>

const int PORT = 8080;

const int BUFFER_SIZE = 1024;

int main() {

int server_fd, new_socket;

struct sockaddr_in address;

int addrlen = sizeof(address);

char buffer[BUFFER_SIZE] = {0};

const char* response = "Message received";

// Creating socket file descriptor

if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {

std::cerr << "Socket creation error" << std::endl;

return -1;

}

address.sin_family = AF_INET;

address.sin_addr.s_addr = INADDR_ANY;

address.sin_port = htons(PORT);

// Bind the socket

if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {

std::cerr << "Bind failed" << std::endl;

return -1;

}

// Listen for incoming connections

if (listen(server_fd, 3) < 0) {

std::cerr << "Listen failed" << std::endl;

return -1;

}

// Accept a connection

if ((new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen)) < 0) {

std::cerr << "Accept failed" << std::endl;

return -1;

}

// Read message from client

read(new_socket, buffer, BUFFER_SIZE);

std::cout << "Received: " << buffer << std::endl;

// Send response to client

send(new_socket, response, strlen(response), 0);

std::cout << "Response sent" << std::endl;

// Close sockets

close(new_socket);

close(server_fd);

return 0;

}

Client Program (client.cpp)

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <cstring>

const int PORT = 8080;
const int BUFFER_SIZE = 1024;

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[BUFFER_SIZE] = {0};
    const char* message = "Hello from client";

    // Creating socket file descriptor
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // Convert IPv4 and IPv6 addresses from text to binary form
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        std::cerr << "Invalid address / Address not supported" << std::endl;
        return -1;
    }

    // Connect to the server
    if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Connection failed" << std::endl;
        return -1;
    }

    // Send message to server
    send(sock, message, strlen(message), 0);
    std::cout << "Message sent" << std::endl;

    // Read response from server
    read(sock, buffer, BUFFER_SIZE);
    std::cout << "Response from server: " << buffer << std::endl;

    // Close socket
    close(sock);

    return 0;
}

#include <iostream>

#include <sys/socket.h>

#include <netinet/in.h>

#include <unistd.h>

#include <cstring>

const int PORT = 8080;

const int BUFFER_SIZE = 1024;

int main() {

int sock = 0;

struct sockaddr_in serv_addr;

char buffer[BUFFER_SIZE] = {0};

const char* message = "Hello from client";

// Creating socket file descriptor

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

std::cerr << "Socket creation error" << std::endl;

return -1;

}

serv_addr.sin_family = AF_INET;

serv_addr.sin_port = htons(PORT);

// Convert IPv4 and IPv6 addresses from text to binary form

if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {

std::cerr << "Invalid address / Address not supported" << std::endl;

return -1;

}

// Connect to the server

if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {

std::cerr << "Connection failed" << std::endl;

return -1;

}

// Send message to server

send(sock, message, strlen(message), 0);

std::cout << "Message sent" << std::endl;

// Read response from server

read(sock, buffer, BUFFER_SIZE);

std::cout << "Response from server: " << buffer << std::endl;

// Close socket

close(sock);

return 0;

}

Explanation: Server Program (server.cpp): Socket Creation: Creates a socket using socket(). Binding: Binds the socket to an IP address and port using bind(). Listening: Sets the socket to listen for incoming connections using listen(). Accepting Connections: Accepts a connection from a client using accept(). Reading/Writing: Reads data …

Simulation of Computer Networking Protocols Gaming Project in C++ Read More »