project/
├── src/
│   ├── main.c
│   ├── functions.c
│   └── headers.h
├── include/
├── tests/
└── Makefile/CMakeLists.txt

#include <iostream>
#include <vector>
#include <string>

class Project {
private:
    std::string name;
    std::vector<std::string> tasks;
    
public:
    Project(const std::string& projectName) : name(projectName) {}
    
    void addTask(const std::string& task) {
        tasks.push_back(task);
    }
    
    void display() {
        std::cout << "Project: " << name << std::endl;
        std::cout << "Tasks:" << std::endl;
        for (const auto& task : tasks) {
            std::cout << "- " << task << std::endl;
        }
    }
};

int main() {
    Project myProject("C++ Project Manager");
    myProject.addTask("Design architecture");
    myProject.addTask("Implement core features");
    myProject.addTask("Write documentation");
    myProject.display();
    
    return 0;
}

// C - رویه‌گرا
#include <stdio.h>
#include <stdlib.h>

struct Student {
    char name[50];
    int age;
};

void printStudent(struct Student s) {
    printf("Name: %s, Age: %d\n", s.name, s.age);
}

// C++ - چندپارادایمی
#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    
public:
    Student(std::string n, int a) : name(n), age(a) {}
    
    void print() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

# نصب روی Ubuntu/Debian
sudo apt-get install gcc g++ clang build-essential

# نصب روی macOS
brew install gcc llvm

# نصب روی Windows
# MinGW-w64 یا Visual Studio Build Tools

# Debugger
gdb ./program
lldb ./program

# Profiler
valgrind --leak-check=full ./program
gprof ./program

# Package Manager
# vcpkg (Microsoft)
# Conan (C++ Package Manager)

# CMakeLists.txt نمونه
cmake_minimum_required(VERSION 3.10)
project(MyProject VERSION 1.0)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED True)

add_executable(myapp src/main.cpp src/utils.cpp)

find_package(Boost REQUIRED COMPONENTS filesystem system)
target_link_libraries(myapp Boost::filesystem Boost::system)

my_project/
├── CMakeLists.txt
├── README.md
├── LICENSE
├── .gitignore
├── .clang-format
├── .github/
│   └── workflows/
│       └── ci-cd.yml
├── docs/
│   ├── architecture.md
│   └── api.md
├── include/
│   └── myproject/
│       ├── core.h
│       ├── utils.h
│       └── algorithms.h
├── src/
│   ├── core/
│   │   ├── core.cpp
│   │   └── data_structures.cpp
│   ├── utils/
│   │   ├── logging.cpp
│   │   └── file_io.cpp
│   └── main.cpp
├── tests/
│   ├── unit/
│   │   ├── test_core.cpp
│   │   └── test_utils.cpp
│   └── integration/
│       └── test_integration.cpp
├── third_party/
├── scripts/
│   ├── build.sh
│   └── deploy.sh
└── examples/
    ├── basic_usage.cpp
    └── advanced_features.cpp

// Singleton Pattern
class Database {
private:
    static Database* instance;
    Database() {} // Constructor private
    
public:
    static Database* getInstance() {
        if (!instance) {
            instance = new Database();
        }
        return instance;
    }
    
    // Delete copy constructor and assignment operator
    Database(const Database&) = delete;
    Database& operator=(const Database&) = delete;
};

// Factory Pattern
class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

class ShapeFactory {
public:
    static Shape* createShape(const std::string& type) {
        if (type == "circle") return new Circle();
        if (type == "square") return new Square();
        return nullptr;
    }
};

// database.h
#pragma once
#include <iostream>
#include <vector>
#include <memory>
#include <fstream>
#include <sstream>
#include <algorithm>

class Table {
private:
    std::string name;
    std::vector<std::vector<std::string>> data;
    std::vector<std::string> columns;
    
public:
    Table(const std::string& tableName, 
          const std::vector<std::string>& cols);
    
    bool insert(const std::vector<std::string>& row);
    bool update(int id, const std::vector<std::string>& newData);
    bool remove(int id);
    std::vector<std::vector<std::string>> select(
        const std::string& whereCondition = "");
    
    void saveToFile(const std::string& filename);
    void loadFromFile(const std::string& filename);
    
    void display() const;
};

class Database {
private:
    std::unordered_map<std::string, Table> tables;
    std::string dbName;
    
public:
    Database(const std::string& name);
    
    bool createTable(const std::string& tableName,
                    const std::vector<std::string>& columns);
    bool dropTable(const std::string& tableName);
    
    void backup(const std::string& backupPath);
    void restore(const std::string& backupPath);
    
    void executeSQL(const std::string& sql);
};

// game_engine.h
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include <vector>
#include <memory>
#include <map>

class TextureManager {
private:
    std::map<std::string, SDL_Texture*> textures;
    SDL_Renderer* renderer;
    
public:
    TextureManager(SDL_Renderer* rend);
    ~TextureManager();
    
    bool load(const std::string& id, const std::string& filename);
    SDL_Texture* get(const std::string& id);
    void drop(const std::string& id);
    void clean();
};

class GameObject {
protected:
    SDL_Rect position;
    SDL_Texture* texture;
    std::string textureId;
    
public:
    GameObject(int x, int y, int w, int h, const std::string& texId);
    virtual ~GameObject();
    
    virtual void update(float deltaTime);
    virtual void render(SDL_Renderer* renderer);
    
    void setPosition(int x, int y);
    SDL_Rect getPosition() const;
    
    virtual void handleEvent(SDL_Event& event);
};

class Game {
private:
    SDL_Window* window;
    SDL_Renderer* renderer;
    bool isRunning;
    Uint32 lastUpdateTime;
    
    TextureManager textureManager;
    std::vector<std::unique_ptr<GameObject>> gameObjects;
    
public:
    Game(const char* title, int width, int height);
    ~Game();
    
    bool initialize();
    void run();
    void clean();
    
    void handleEvents();
    void update();
    void render();
    
    void addObject(std::unique_ptr<GameObject> object);
};

// compiler.h
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <memory>

enum class TokenType {
    IDENTIFIER, NUMBER, STRING,
    PLUS, MINUS, MULTIPLY, DIVIDE,
    EQUAL, NOT_EQUAL, LESS, GREATER,
    ASSIGN, SEMICOLON, COMMA,
    LPAREN, RPAREN, LBRACE, RBRACE,
    IF, ELSE, WHILE, FOR, RETURN,
    INT, FLOAT, VOID,
    EOF_TOKEN
};

struct Token {
    TokenType type;
    std::string value;
    int line;
    int column;
};

class Lexer {
private:
    std::string source;
    int position;
    int line;
    int column;
    
    char peek();
    char advance();
    bool match(char expected);
    
    Token identifier();
    Token number();
    Token stringLiteral();
    
public:
    Lexer(const std::string& src);
    Token nextToken();
    std::vector<Token> tokenize();
};

class ASTNode {
public:
    virtual ~ASTNode() = default;
    virtual void print(int indent = 0) const = 0;
};

class Parser {
private:
    std::vector<Token> tokens;
    int current;
    
    Token peek();
    Token previous();
    Token advance();
    bool check(TokenType type);
    bool match(TokenType type);
    
    std::unique_ptr<ASTNode> parseExpression();
    std::unique_ptr<ASTNode> parseStatement();
    std::unique_ptr<ASTNode> parseIfStatement();
    std::unique_ptr<ASTNode> parseWhileStatement();
    std::unique_ptr<ASTNode> parseFunction();
    
public:
    Parser(const std::vector<Token>& toks);
    std::unique_ptr<ASTNode> parse();
};

class CodeGenerator {
private:
    std::ostream& output;
    int labelCounter;
    
    std::string newLabel();
    
public:
    CodeGenerator(std::ostream& out);
    
    void generate(ASTNode* node);
    void generateExpression(ASTNode* node);
    void generateStatement(ASTNode* node);
    void generateIf(ASTNode* node);
    void generateWhile(ASTNode* node);
};

// 1. حرکت محاسبات به زمان کامپایل
constexpr int factorial(int n) {
    return (n <= 1) ? 1 : (n * factorial(n - 1));
}

// 2. استفاده از حرکت معنایی (Move Semantics)
class Buffer {
private:
    size_t size;
    int* data;
    
public:
    // Move Constructor
    Buffer(Buffer&& other) noexcept 
        : size(other.size), data(other.data) {
        other.data = nullptr;
        other.size = 0;
    }
    
    // Move Assignment
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};

// 3. حافظه‌سازی (Memoization)
#include <unordered_map>

template<typename T>
class Fibonacci {
private:
    mutable std::unordered_map<int, T> cache;
    
public:
    T calculate(int n) const {
        if (n <= 1) return n;
        
        auto it = cache.find(n);
        if (it != cache.end()) {
            return it->second;
        }
        
        T result = calculate(n - 1) + calculate(n - 2);
        cache[n] = result;
        return result;
    }
};

// 4. SIMD با استفاده از intrinsics
#include <immintrin.h>

void vectorAdd(float* a, float* b, float* c, int n) {
    for (int i = 0; i < n; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_store_ps(&c[i], vc);
    }
}

# 1. آنالیز حافظه با Valgrind
valgrind --tool=memcheck --leak-check=full --show-leak-kinds=all ./program

# 2. پروفایلینگ با gprof
gcc -pg -o program program.c
./program
gprof program gmon.out > analysis.txt

# 3. آنالیز استاتیک با cppcheck
cppcheck --enable=all --inconclusive --std=c++17 src/

# 4. Sanitizers
gcc -fsanitize=address -fsanitize=undefined -g program.c

// استفاده از Google Test
#include <gtest/gtest.h>

TEST(DatabaseTest, TableCreation) {
    Database db("test_db");
    EXPECT_TRUE(db.createTable("users", {"id", "name", "email"}));
    EXPECT_FALSE(db.createTable("users", {"id", "name"})); // Already exists
}

TEST(DatabaseTest, DataInsertion) {
    Database db("test_db");
    db.createTable("users", {"id", "name"});
    
    Table& users = db.getTable("users");
    EXPECT_TRUE(users.insert({"1", "John Doe"}));
    EXPECT_EQ(users.rowCount(), 1);
}

// CMake integration برای Google Test
find_package(GTest REQUIRED)
add_executable(runTests test_database.cpp)
target_link_libraries(runTests GTest::gtest GTest::gtest_main)
enable_testing()
add_test(NAME DatabaseTests COMMAND runTests)

# .github/workflows/ci.yml
name: C++ CI

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Install dependencies
      run: |
        sudo apt-get update
        sudo apt-get install -y g++ cmake libgtest-dev
        
    - name: Configure CMake
      run: cmake -B build -DCMAKE_BUILD_TYPE=Release
      
    - name: Build
      run: cmake --build build
      
    - name: Run tests
      run: ./build/tests/runTests
      
    - name: Code coverage
      run: |
        sudo apt-get install -y lcov
        lcov --capture --directory . --output-file coverage.info
        lcov --remove coverage.info '/usr/*' --output-file coverage.info
        lcov --list coverage.info

class DistributedFileSystem {
private:
    struct Chunk {
        std::string chunkId;
        std::vector<std::string> nodeLocations;
        size_t size;
        time_t lastModified;
    };
    
    struct FileMetadata {
        std::string filename;
        std::vector<Chunk> chunks;
        std::map<std::string, std::string> attributes;
        AccessControlList acl;
    };
    
    std::map<std::string, FileMetadata> fileTable;
    std::vector<StorageNode> storageNodes;
    
public:
    class StorageNode {
    private:
        std::string nodeId;
        std::string address;
        uint16_t port;
        size_t availableSpace;
        std::map<std::string, Chunk> storedChunks;
        
    public:
        bool storeChunk(const Chunk& chunk, const std::vector<char>& data);
        std::vector<char> retrieveChunk(const std::string& chunkId);
        bool deleteChunk(const std::string& chunkId);
        size_t getAvailableSpace() const;
    };
    
    bool uploadFile(const std::string& localPath, 
                   const std::string& remotePath,
                   int replicationFactor = 3);
    
    bool downloadFile(const std::string& remotePath,
                     const std::string& localPath);
    
    bool deleteFile(const std::string& path);
    std::vector<std::string> listFiles(const std::string& directory);
    
    void rebalanceStorage();
    void repairReplication();
};

class PhysicsEngine {
private:
    struct RigidBody {
        Vector3 position;
        Vector3 velocity;
        Vector3 acceleration;
        Quaternion rotation;
        Vector3 angularVelocity;
        float mass;
        float inertia;
        Collider* collider;
        
        void integrate(float deltaTime);
    };
    
    struct Collider {
        enum Type { SPHERE, BOX, CAPSULE, MESH };
        Type type;
        std::vector<Vector3> vertices;
        std::vector<Triangle> triangles;
        BoundingBox bounds;
        
        bool intersects(const Collider& other, 
                       CollisionInfo& info) const;
    };
    
    std::vector<RigidBody> bodies;
    BroadPhaseSpatialGrid spatialGrid;
    
public:
    void stepSimulation(float deltaTime);
    
    void addBody(const RigidBody& body);
    void removeBody(int id);
    
    std::vector<CollisionInfo> detectCollisions();
    void resolveCollisions(const std::vector<CollisionInfo>& collisions);
    
    void applyForce(int bodyId, const Vector3& force, 
                   const Vector3& point);
    void applyImpulse(int bodyId, const Vector3& impulse,
                     const Vector3& point);
    
    void setGravity(const Vector3& gravity);
    
private:
    void broadPhase();
    void narrowPhase();
    void solveConstraints();
    void updateSpatialGrid();
};

class HttpServer {
private:
    class Connection {
    private:
        int socket;
        std::string buffer;
        
        HttpRequest parseRequest();
        HttpResponse handleRequest(const HttpRequest& req);
        void sendResponse(const HttpResponse& res);
        
    public:
        Connection(int sock);
        void process();
    };
    
    int serverSocket;
    std::thread acceptorThread;
    std::vector<std::thread> workerThreads;
    ThreadPool threadPool;
    
    std::map<std::string, 
            std::function<HttpResponse(const HttpRequest&)>> routes;
    
    void acceptConnections();
    
public:
    HttpServer(int port = 8080, int threadCount = 4);
    ~HttpServer();
    
    void start();
    void stop();
    
    void get(const std::string& path,
            std::function<HttpResponse(const HttpRequest&)> handler);
    
    void post(const std::string& path,
             std::function<HttpResponse(const HttpRequest&)> handler);
    
    void put(const std::string& path,
            std::function<HttpResponse(const HttpRequest&)> handler);
    
    void delete_(const std::string& path,
                std::function<HttpResponse(const HttpRequest&)> handler);
    
    void serveStatic(const std::string& urlPath,
                    const std::string& filePath);
};

// hotel_management.h
#include <iostream>
#include <vector>
#include <map>
#include <memory>
#include <fstream>
#include <iomanip>
#include <ctime>
#include <algorithm>

namespace HotelManagement {
    
    class Date {
    private:
        int day, month, year;
        
    public:
        Date(int d, int m, int y);
        static Date today();
        std::string toString() const;
        bool operator<(const Date& other) const;
        int daysBetween(const Date& other) const;
    };
    
    class Room {
    public:
        enum Type { SINGLE, DOUBLE, SUITE, PRESIDENTIAL };
        enum Status { AVAILABLE, OCCUPIED, MAINTENANCE };
        
    private:
        int roomNumber;
        Type type;
        Status status;
        double pricePerNight;
        std::vector<std::string> amenities;
        
    public:
        Room(int number, Type t, double price);
        
        int getNumber() const;
        Type getType() const;
        Status getStatus() const;
        double getPrice() const;
        
        void setStatus(Status s);
        void addAmenity(const std::string& amenity);
        void display() const;
        
        bool isAvailable() const;
        bool matchesCriteria(Type desiredType, 
                           double maxPrice) const;
    };
    
    class Guest {
    private:
        std::string id;
        std::string name;
        std::string email;
        std::string phone;
        std::string address;
        std::vector<std::string> preferences;
        
    public:
        Guest(const std::string& n, const std::string& e, 
              const std::string& p);
        
        void addPreference(const std::string& preference);
        void updateInfo(const std::string& newEmail, 
                       const std::string& newPhone);
        void display() const;
        
        std::string getId() const;
        std::string getName() const;
    };
    
    class Reservation {
    private:
        std::string reservationId;
        Guest guest;
        Room room;
        Date checkIn;
        Date checkOut;
        double totalCost;
        std::string specialRequests;
        bool isPaid;
        
    public:
        Reservation(const Guest& g, const Room& r,
                   const Date& in, const Date& out);
        
        void calculateCost();
        void markAsPaid();
        void cancel();
        
        void display() const;
        std::string generateInvoice() const;
        
        bool overlaps(const Date& start, const Date& end) const;
        int getDuration() const;
    };
    
    class Hotel {
    private:
        std::string name;
        std::vector<Room> rooms;
        std::map<std::string, Guest> guests;
        std::vector<Reservation> reservations;
        std::vector<Reservation> history;
        
        std::map<Date, std::vector<int>> availabilityCalendar;
        
    public:
        Hotel(const std::string& hotelName);
        
        // Room management
        void addRoom(const Room& room);
        bool removeRoom(int roomNumber);
        std::vector<Room> findAvailableRooms(Date start, Date end,
                                           Room::Type type) const;
        
        // Guest management
        std::string registerGuest(const Guest& guest);
        bool updateGuest(const std::string& guestId,
                        const Guest& updatedInfo);
        
        // Reservation management
        std::string makeReservation(const std::string& guestId,
                                  int roomNumber,
                                  Date checkIn, Date checkOut);
        bool cancelReservation(const std::string& reservationId);
        void checkIn(const std::string& reservationId);
        void checkOut(const std::string& reservationId);
        
        // Reporting
        double calculateDailyRevenue(const Date& date) const;
        double calculateMonthlyRevenue(int month, int year) const;
        std::map<Room::Type, int> getOccupancyRate() const;
        
        // Persistence
        void saveToFile(const std::string& filename) const;
        void loadFromFile(const std::string& filename);
        
        // Staff management
        void addStaff(const std::string& name, 
                     const std::string& position);
        void generatePayroll() const;
        
        // Inventory management
        void addInventoryItem(const std::string& item,
                            int quantity);
        void updateInventory(const std::string& item,
                           int quantity);
        void generateInventoryReport() const;
    };
    
    class UserInterface {
    private:
        Hotel& hotel;
        
        void displayMenu();
        void handleGuestRegistration();
        void handleRoomBooking();
        void handleCheckIn();
        void handleCheckOut();
        void handleRoomService();
        void generateReports();
        
    public:
        UserInterface(Hotel& h);
        void run();
    };
}