C++パフォーマンス最適化の基本概念と実践手法

#include <iostream>
#include <chrono>

void exampleFunction() {
    // 処理内容
}

int main() {
    auto start = std::chrono::high_resolution_clock::now();

    exampleFunction();

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration = end - start;

    std::cout << "Execution time: " << duration.count() << " seconds" << std::endl;
    return 0;
}

#include <memory>
#include <iostream>

void exampleFunction() {
    std::unique_ptr<int> ptr = std::make_unique<int>(10);
    std::cout << *ptr << std::endl; // 出力: 10
}

#include <iostream>
#include <fstream>

class FileWriter {
public:
    FileWriter(const std::string& filename) : file(filename) {
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
    }
    ~FileWriter() {
        file.close();
    }
    void write(const std::string& message) {
        file << message << std::endl;
    }
private:
    std::ofstream file;
};

void exampleFunction() {
    FileWriter writer("example.txt");
    writer.write("Hello, RAII!");
}

valgrind --leak-check=full ./your_program

g++ -O2 -o optimized_program source.cpp

g++ -O2 -funroll-loops -finline-functions -o highly_optimized_program source.cpp

clang++ -O2 -o optimized_program source.cpp

cl /O2 source.cpp /Fe:optimized_program.exe

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    numbers.push_back(6);

    for (int number : numbers) {
        std::cout << number << " ";
    }
    return 0;
}

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> ages;
    ages["Alice"] = 30;
    ages["Bob"] = 25;

    for (const auto& entry : ages) {
        std::cout << entry.first << ": " << entry.second << std::endl;
    }
    return 0;
}

#include <iostream>
#include <thread>

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");

    t1.join();
    t2.join();

    return 0;
}

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    std::for_each(std::execution::par, numbers.begin(), numbers.end(), [](int& n) {
        n *= 2;
    });

    for (const auto& n : numbers) {
        std::cout << n << " ";
    }

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void printMessage(const std::string& message) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");

    t1.join();
    t2.join();

    return 0;
}

#include <iostream>
#include <future>

int computeSquare(int x) {
    return x * x;
}

int main() {
    std::future<int> result = std::async(std::launch::async, computeSquare, 5);

    std::cout << "The square of 5 is " << result.get() << std::endl;

    return 0;
}

#include <iostream>
#include <fstream>
#include <vector>

int main() {
    std::ofstream file("example.txt", std::ios::out | std::ios::binary);

    // バッファのサイズを設定
    file.rdbuf()->pubsetbuf(0, 0);

    std::vector<char> buffer(1024);
    // 大量のデータを書き込む
    for (int i = 0; i < 10000; ++i) {
        file.write(buffer.data(), buffer.size());
    }

    file.close();
    return 0;
}

#include <iostream>
#include <future>
#include <fstream>

void writeFileAsync(const std::string& filename, const std::string& data) {
    std::ofstream file(filename);
    file << data;
}

int main() {
    std::string data = "This is a sample text.";
    std::future<void> result = std::async(std::launch::async, writeFileAsync, "example.txt", data);

    // 他の作業を並行して実行
    std::cout << "Writing to file asynchronously..." << std::endl;

    result.get(); // 書き込みが完了するのを待つ
    return 0;
}

#include <iostream>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        std::cerr << "Error opening file" << std::endl;
        return 1;
    }

    // ファイルサイズを取得
    off_t fileSize = lseek(fd, 0, SEEK_END);
    void* fileMemory = mmap(NULL, fileSize, PROT_READ, MAP_PRIVATE, fd, 0);

    if (fileMemory == MAP_FAILED) {
        std::cerr << "Error mapping file" << std::endl;
        close(fd);
        return 1;
    }

    // ファイル内容を出力
    std::cout.write(static_cast<char*>(fileMemory), fileSize);

    munmap(fileMemory, fileSize);
    close(fd);
    return 0;
}

#include <iostream>
#include <boost/asio.hpp>

void handle_read(const boost::system::error_code& err, std::size_t bytes_transferred) {
    if (!err) {
        std::cout << "Read " << bytes_transferred << " bytes" << std::endl;
    }
}

int main() {
    boost::asio::io_context io_context;
    boost::asio::ip::tcp::socket socket(io_context);
    boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::address::from_string("127.0.0.1"), 8080);

    socket.connect(endpoint);

    boost::asio::streambuf buffer;
    boost::asio::async_read(socket, buffer, handle_read);

    io_context.run();
    return 0;
}

#include <iostream>

inline int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

#include <iostream>

int main() {
    const int size = 8;
    int array[size] = {1, 2, 3, 4, 5, 6, 7, 8};
    int sum = 0;

    for (int i = 0; i < size; i += 4) {
        sum += array[i] + array[i + 1] + array[i + 2] + array[i + 3];
    }

    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

#include <iostream>

int main() {
    const int size = 1000;
    int array[size];
    int sum = 0;

    for (int i = 0; i < size; ++i) {
        sum += array[i];
    }

    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

#include <iostream>

int main() {
    const int size = 100;
    int matrix[size][size];
    int sum = 0;

    // 行優先のアクセス
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            sum += matrix[i][j];
        }
    }

    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sum = 0;

    for (const auto& value : data) {
        if (value % 2 == 0) {
            sum += value;
        }
    }

    std::cout << "Sum of even numbers: " << sum << std::endl;
    return 0;
}

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("Division by zero");
    }
    return a / b;
}

int main() {
    try {
        int result = divide(10, 0);
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

#include <iostream>
#include <optional>

std::optional<int> safeDivide(int a, int b) {
    if (b == 0) {
        return std::nullopt;
    }
    return a / b;
}

int main() {
    auto result = safeDivide(10, 0);
    if (result) {
        std::cout << "Result: " << *result << std::endl;
    } else {
        std::cerr << "Error: Division by zero" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::runtime_error("Runtime error");
    } catch (const std::runtime_error& e) {
        std::cerr << "Runtime error caught: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Other exception caught: " << e.what() << std::endl;
    }
    return 0;
}

#include <iostream>
#include <stdexcept>

void throwException() {
    static const std::string errorMessage = "Error occurred";
    throw std::runtime_error(errorMessage);
}

int main() {
    try {
        throwException();
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
    return 0;
}

#include <iostream>
#include <stdexcept>

void process() {
    try {
        int a = 10;
        int b = 0;
        if (b == 0) {
            throw std::invalid_argument("Division by zero");
        }
        int result = a / b;
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}

int main() {
    process();
    return 0;
}

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

void highPriorityTask() {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "High priority task completed" << std::endl;
}

void lowPriorityTask() {
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    std::cout << "Low priority task completed" << std::endl;
}

int main() {
    std::thread high(highPriorityTask);
    std::thread low(lowPriorityTask);

    // スレッドの優先度を設定する（プラットフォーム依存のため擬似コード）
    // setPriority(high, HIGH_PRIORITY);
    // setPriority(low, LOW_PRIORITY);

    high.join();
    low.join();
    return 0;
}

#include <iostream>
#include <vector>
#include <memory>

class QuadTree {
public:
    QuadTree(int level, int maxLevel) : level(level), maxLevel(maxLevel) {}

    void insert(int x, int y) {
        if (level == maxLevel) {
            points.emplace_back(x, y);
        } else {
            // サブツリーに挿入
        }
    }

private:
    int level;
    int maxLevel;
    std::vector<std::pair<int, int>> points;
    std::unique_ptr<QuadTree> subTrees[4];
};

int main() {
    QuadTree tree(0, 3);
    tree.insert(5, 10);
    tree.insert(15, 20);
    std::cout << "Points inserted into QuadTree" << std::endl;
    return 0;
}

#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<std::string, int> data;
    data["apple"] = 10;
    data["banana"] = 20;
    data["cherry"] = 30;

    for (const auto& item : data) {
        std::cout << item.first << ": " << item.second << std::endl;
    }
    return 0;
}

#include <iostream>
#include <boost/asio.hpp>
#include <thread>

void session(boost::asio::ip::tcp::socket socket) {
    try {
        char data[1024];
        boost::system::error_code error;
        size_t length = socket.read_some(boost::asio::buffer(data), error);
        if (!error) {
            std::cout << "Received: " << std::string(data, length) << std::endl;
        }
    } catch (std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
}

int main() {
    try {
        boost::asio::io_context io_context;
        boost::asio::ip::tcp::acceptor acceptor(io_context, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 12345));

        while (true) {
            boost::asio::ip::tcp::socket socket(io_context);
            acceptor.accept(socket);
            std::thread(session, std::move(socket)).detach();
        }
    } catch (std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
    return 0;
}