C++ Academy · Pelajaran

Catatan Performa

Kompilasi pola dengan bijak

Catatan Performa adalah pelajaran C++ Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C++ Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C++ Academy mencakup 4 pelajaran total.

Kompilasi Itu Mahal

Membangun std::regex dari string akan mengompilasi pola tersebut, yang membutuhkan biaya besar. Keuntungan terbesar diperoleh dengan mengompilasi sekali lalu menggunakannya kembali.

Hindari membuat regex di dalam pengulangan.
Kompilasi saat memulai atau saat pertama kali digunakan.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d+");
    std::string inputs[] = {"12", "ab", "99"};
    for (const auto& s : inputs) {
        std::cout << s << ": " << std::regex_match(s, p) << '\n';
    }
    return 0;
}

Gunakan Kembali Pola yang Telah Dikompilasi

Buat pola sekali di luar pengulangan, lalu gunakan kembali untuk setiap masukan. Membuatnya ulang pada setiap iterasi hanya membuang waktu.

#include <iostream>
#include <regex>
#include <vector>

int main() {
    static const std::regex p("[a-z]+");
    std::vector<std::string> words = {"hello", "WORLD", "cpp"};
    int matches = 0;
    for (const auto& w : words) {
        if (std::regex_match(w, p)) ++matches;
    }
    std::cout << "Matched: " << matches << '\n';
    return 0;
}

Mendeklarasikan Konstanta Sekali Saja

Untuk pola yang tidak pernah berubah, deklarasikan pola tersebut sebagai static const di dalam fungsi agar dikompilasi tepat satu kali untuk semua pemanggilan.

#include <iostream>
#include <regex>

bool isEmail(const std::string& s) {
    static const std::regex p("\\w+@\\w+\\.\\w+");
    return std::regex_match(s, p);
}

int main() {
    std::cout << std::boolalpha;
    std::cout << isEmail("a@b.com") << '\n';
    std::cout << isEmail("nope") << '\n';
    return 0;
}

Pilih Tata Bahasa yang Tepat

Varian ekspresi reguler (tata bahasa) memengaruhi kecepatan dan fitur. std::regex::ECMAScript adalah bawaan dan paling lengkap; std::regex::basic atau extended lebih sederhana dan terkadang lebih cepat.

#include <iostream>
#include <regex>

int main() {
    std::regex p("a+", std::regex::extended);
    std::cout << std::boolalpha << std::regex_match("aaa", p) << '\n';
    return 0;
}

Tanda Pengoptimalan

Menambahkan std::regex::optimize memberi tahu mesin untuk menghabiskan lebih banyak waktu saat membangun pola sebagai imbalan atas pencocokan yang lebih cepat. Hal ini bermanfaat ketika Anda melakukan pencocokan berkali-kali.

#include <iostream>
#include <regex>

int main() {
    std::regex p("\\d{3}-\\d{4}", std::regex::optimize);
    std::cout << std::boolalpha << std::regex_match("123-4567", p) << '\n';
    return 0;
}

Hindari Penelusuran Balik yang Menghancurkan Kinerja

Kuantifikator bertingkat seperti (a+)+ dapat berkembang menjadi waktu eksponensial pada masukan tertentu. Utamakan pola yang lebih sederhana dan tidak ambigu.

#include <iostream>
#include <regex>

int main() {
    std::regex good("a+b");
    std::cout << std::boolalpha << std::regex_match("aaaab", good) << '\n';
    return 0;
}

Gunakan Jangkar Jika Memungkinkan

Pemasangan jangkar dengan ^ dan $ memungkinkan mesin gagal dengan cepat, alih-alih mencoba setiap posisi awal.

#include <iostream>
#include <regex>

int main() {
    std::regex p("^[a-z]{3}$");
    std::cout << std::boolalpha;
    std::cout << std::regex_search("abc", p) << '\n';
    std::cout << std::regex_search("abcd", p) << '\n';
    return 0;
}

Utamakan Alat Sederhana Jika Memungkinkan

Jika Anda hanya perlu memeriksa bagian teks tetap, std::string::find jauh lebih cepat daripada ekspresi reguler. Gunakan ekspresi reguler hanya untuk pencocokan pola yang sebenarnya.

#include <iostream>
#include <string>

int main() {
    std::string s = "hello world";
    bool has = s.find("world") != std::string::npos;
    std::cout << std::boolalpha << has << '\n';
    return 0;
}

Menggunakan Kembali Objek Pencocokan

Saat melakukan pencarian berulang, gunakan kembali satu std::smatch daripada membuat yang baru setiap kali untuk mengurangi biaya tambahan.

#include <iostream>
#include <regex>
#include <vector>

int main() {
    static const std::regex p("(\\d+)");
    std::smatch m;
    std::vector<std::string> data = {"x1", "y22", "z333"};
    for (const auto& s : data) {
        if (std::regex_search(s, m, p)) std::cout << m[1] << ' ';
    }
    std::cout << '\n';
    return 0;
}

Persempit Pola Anda

Kelas karakter yang spesifik cocok lebih cepat dan lebih aman daripada titik yang mencocokkan apa pun. Gunakan [0-9] alih-alih . jika yang dimaksud adalah angka.

#include <iostream>
#include <regex>

int main() {
    std::regex specific("[0-9]{2}");
    std::cout << std::boolalpha;
    std::cout << std::regex_match("42", specific) << '\n';
    std::cout << std::regex_match("ab", specific) << '\n';
    return 0;
}

Ukur Sebelum Mengoptimalkan

Gabungkan pemahaman Anda tentang <chrono>: ukur waktu penggunaan regex Anda untuk memastikan perubahan tersebut benar-benar membantu sebelum menerapkannya.

#include <iostream>
#include <regex>
#include <chrono>

int main() {
    using namespace std::chrono;
    static const std::regex p("\\d+");
    auto s = steady_clock::now();
    int hits = 0;
    for (int i = 0; i < 1000; ++i) {
        if (std::regex_search(std::string("x") + std::to_string(i), p)) ++hits;
    }
    auto e = steady_clock::now();
    std::cout << "hits=" << hits << ", timed: " << ((e - s).count() >= 0) << '\n';
    return 0;
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang kinerja regex.

Ringkasan

Anda telah mempelajari cara menggunakan regex secara efisien:

kompilasikan pola sekali, idealnya static const, lalu gunakan kembali
pilih tata bahasa yang tepat dan pertimbangkan optimize
hindari penelusuran mundur yang bersifat katastrofik dan gunakan jangkar jika memungkinkan
gunakan alat yang lebih sederhana seperti find untuk bagian teks tetap, lalu ukur perubahannya

Kursus Ekspresi Reguler telah selesai.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Catatan Performa” gratis?

Ya — teks lengkap “Catatan Performa” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C++ Academy, upgrade ke CoddyKit PRO. Kursus C++ Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Catatan Performa”?

Kompilasi pola dengan bijak Kamu berlatih C++ Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C++ Academy?

Tidak diperlukan pengalaman sebelumnya. C++ Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Catatan Performa” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C++ Academy ini?

Ya. Setiap pelajaran C++ Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C++ Academy