Leistungstest: ASCII- und Wide-Strings mit std::cout / std::wcout

Der folgende Test vergleicht die Ausführungszeit von ASCII- und Wide-Strings bei der Ausgabe mit std::cout und std::wcout auf verschiedenen Architekturen (x86 und x64).

1. Test: 1.000.000 ASCII-Strings mit std::cout

#include <iostream>
#include <chrono>
#include <string>

std::string generate_ascii_string(int n) {
    std::string s = "A";
    for (int i = 0; i < n; ++i) {
        s += 'A' + (i % 26);
    }
    return s;
}

void run_cout_ascii() {
    std::cout << "\n===  1.000.000 ASCII-Strings mit cout ===\n";

    const int N = 1000000;
    std::string s = generate_ascii_string(10);

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

    for (int i = 0; i < N; ++i) {
        std::cout << s << std::endl;
    }

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

    std::cout << "Dauer: " << duration.count() << " Mikrosekunden\n";
}

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

2. Test: 1.000.000 Wide-Strings mit std::wcout

#include <iostream>
#include <chrono>
#include <string>

std::wstring generate_wide_string(int n) {
    std::wstring s = L"A";
    for (int i = 0; i < n; ++i) {
        s += L'A' + (i % 26);
    }
    return s;
}

void run_wcout_wide() {
  
    std::wcout << "\n===  1.000.000 Wide-Strings mit wcout ===\n";

    const int N = 1000000;
    std::wstring s = generate_wide_string(10);

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

    for (int i = 0; i < N; ++i) {
        std::wcout << s << std::endl;
    }

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

    std::wcout << L"Dauer: " << duration.count() << L" Mikrosekunden\n";
}

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

Ergebnisübersicht

ASCII-Strings: Geringe Ausführungszeit (ca. 47–53 Millionen Mikrosekunden) – effizient für einfache Zeichenfolgen.
Wide-Strings: Signifikant langsamer (ca. 310–320 Millionen Mikrosekunden) – nötig für Unicode, aber mit höherem Overhead.

Quelle: C++-Testprogramme mit std::cout und std::wcout, ausgeführt auf x86 und x64 Plattformen.