DEV Community: Yilong Wu

My STL Post Sparked a Real Discussion — Here's Where It Landed

Yilong Wu — Sat, 25 Jul 2026 12:58:07 +0000

Algorymer came back with more thoughts after the AoC article. The conversation drifted from "which container to use" to something bigger: is the tool even the point?

The argument, summarized

Their point: the real skill isn't picking between vector and map. It's breaking down a problem on paper first. Language and data structures are just implementation details. A good solution works in any language.

They're not wrong.

Where I agree

When I solve problems on Luogu, I sketch on scratch paper before typing. Not because it looks smart — because jumping straight to code means rewriting everything three times.

The container choice comes after you understand the problem. If you don't know what operations you need, how can you pick the right tool?

Where I still disagree (respectfully)

Yes, the core skill is problem-solving. But here's the thing: if your go-to solution for every problem is int arr[1000], you're making the problem-solving step harder too. You're translating the problem into a form your limited toolbox can handle, instead of into its natural shape.

Picking the right container IS part of problem-solving. It's not separate from it.

The middle ground

Someone in the thread said: use pen and paper, use imagination, the language doesn't matter.

I'd say: use pen and paper first. But when you reach for the keyboard, reach for the tool that matches your mental model. If your brain sees stacks, type stack. If your brain sees key-value pairs, type map. That way the code validates your thinking instead of fighting it.

Thanks Algorymer for pushing the discussion beyond syntax. That's the good stuff.

My GitHub: https://github.com/Cn-Alanwu

Someone Commented on My STL Post — Here's the Follow-Up

Yilong Wu — Fri, 24 Jul 2026 06:57:51 +0000

I wrote "Stop Using Arrays for Everything" and someone in the comments said: "Cool, now solve Advent of Code 2022 Day 5 your way." Challenge accepted.

The problem

Day 5 of AoC 2022: you have 9 stacks of crates. The input gives you the initial stacks, then a list of moves like "move 3 from stack 1 to stack 2". Move crates one at a time, maintaining order.

Here's what a beginner (past me) might write:

char stacks[9][100];  // fixed size, wasted space
int tops[9] = {0};    // manually track height for each stack

// Push a crate
stacks[from][tops[from]++] = 'A';  // off-by-one nightmare

You're managing two parallel arrays and a bunch of indices. It works but it's messy, rigid, and the code doesn't match the problem description at all.

The right tool exists

The problem literally calls them "stacks." C++ has std::stack. Use it.

#include <stack>
#include <vector>

vector<stack<char>> stacks(9);

// Push a crate
stacks[from].push('A');

// Pop a crate
char c = stacks[from].top();
stacks[from].pop();

No manual tops[] array. No fixed capacity. push() and pop() are exactly the words the problem statement uses. The code reads like English.

The full move logic

for (int i = 0; i < count; i++) {
    stacks[to].push(stacks[from].top());
    stacks[from].pop();
}

Three lines. If you wrote this with raw arrays, it would be twice as long and you'd spend half your time debugging an index.

Why this matters

The Advent of Code commenter was right — it's the perfect demo. When the problem says "stack," and your language has a stack class, the default should be to use it, not to reinvent it with arrays "because I know arrays."

Picking the right container isn't about being fancy. It's about writing code that you can look at two weeks later and still understand instantly.

My GitHub: https://github.com/Cn-Alanwu

Stop Using Arrays for Everything

Yilong Wu — Thu, 23 Jul 2026 01:03:34 +0000

I'm AlanWu. When I started C++, my answer to "I need to store multiple things" was always an array. int arr[1000]. Every time.

Then I discovered the STL containers and realized I'd been working way too hard. Here's when to use what.

vector — your new default

If you used to write int arr[1000], use vector<int> arr instead. It grows, it shrinks, it knows its own size, and you can pass it to functions without also passing the length separately.

// Old way
int scores[100];
int n = 0;
scores[n++] = 95;  // hope n doesn't exceed 99

// New way
vector<int> scores;
scores.push_back(95);  // never overflow, never count manually

Use vector when: you need a list of things, in order, and you mainly add to the end or access by index.

Don't use vector when: you need to frequently insert or delete from the middle. That's O(n) — every element after shifts.

map — when you need to look stuff up by name

Arrays and vectors use integer indices. What if you want to look up a student's score by their name, not by number?

map<string, int> scores;
scores["Alice"] = 95;
scores["Bob"] = 88;

cout << scores["Alice"];  // 95

Under the hood, map is a balanced binary search tree. Lookup is O(log n), not O(1). But for most things, it's fast enough and the code is dead simple.

Use map when: you have key-value pairs and keys are not just 0, 1, 2, 3...

Don't use map when: you only need integer indices — that's what vector is for. Or when you need O(1) average lookup — then use unordered_map.

unordered_map — same thing, but faster (usually)

unordered_map<string, int> scores;
scores["Alice"] = 95;

Looks identical to map. The difference: unordered_map uses a hash table. Average lookup is O(1) instead of O(log n). But worst case is O(n) if there are collisions, keys have no order, and it uses more memory.

My rule: start with unordered_map. If you need keys in sorted order, switch to map.

set — when you only care if something exists

Need to track which IDs you've seen? Don't use a vector and loop through it every time.

set<int> seen;
seen.insert(42);
seen.insert(17);

if (seen.count(42)) {  // true — O(log n)
    // already seen it
}

set stores unique values in sorted order. No duplicates allowed.

For O(1) average and no ordering needed: unordered_set.

The actual decision tree

Do you access by position (0, 1, 2...)? → vector.
Do you need to look up by something that isn't a number? → unordered_map.
Do those keys need to be sorted? → map.
Do you only care "have I seen this before"? → unordered_set.
Do you need those values in order or without duplicates? → set.

That covers 90% of cases.

The one you probably don't need: deque

I see beginners use deque because it sounds cool. Double-ended queue. Insert at both ends.

Unless you're writing a sliding window algorithm or a scheduler, you don't need deque. vector with push_back is faster and simpler.

Bottom line

Next time you reach for a plain array, ask: could a vector, map, or set do this in half the code? The answer is usually yes.

My GitHub: https://github.com/Cn-Alanwu

Write Code You Can Still Read 6 Months Later

Yilong Wu — Wed, 22 Jul 2026 00:38:15 +0000

I'm AlanWu. I'm in junior high. I've written a lot of bad code. Here's what I changed to make it less bad.

1. Name things like a human

// Don't do this
int d;          // days? distance? damage?
int cnt = 0;    // "cnt" — you know, the classic
vector<int> v;  // v of what

// Do this
int daysUntilDeadline;
int errorCount = 0;
vector<int> studentScores;

Full words, no abbreviations. idx instead of i in loops is fine. But sz for size, cnt for count, ptr for pointer — just type the word. You're not being charged by the character.

2. Functions should do one thing

If you need the word "and" to describe a function, split it.

// Bad: does two things, name lies
void loadAndValidateConfig() {
    readFile();
    checkSyntax();
}

// Better
Config loadConfig(string path) {
    return parseConfig(readFile(path));
}

bool validateConfig(const Config& cfg) {
    return cfg.width > 0 && cfg.height > 0;
}

My rule of thumb: if a function is longer than what fits on one screen, break it. If I can't describe what it does in one sentence without "and", break it.

3. Comments explain WHY, not WHAT

// Bad — tells me what the code already says
// Loop through all students
for (auto& s : students) {
    s.score += 5;
}

// Good — tells me WHY, which the code can't
// Extra credit: 5 points for submitting early
for (auto& s : students) {
    s.score += 5;
}

If you're writing a comment that just restates the next line of code, delete it. The only comments worth keeping are the ones that answer "why did I do it this way?"

4. Don't nest too deep

// Bad — 3 levels deep, I've already forgotten what the top level was
for (auto& student : students) {
    if (student.hasSubmitted()) {
        for (auto& answer : student.answers) {
            if (answer.isCorrect()) {
                score++;
            }
        }
    }
}

// Better — flatten with early exits
for (auto& student : students) {
    if (!student.hasSubmitted()) continue;
    for (auto& answer : student.answers) {
        if (!answer.isCorrect()) continue;
        score++;
    }
}

Also: if you have if (a) { if (b) { if (c) { ... } } } with no else, just combine them: if (a && b && c).

5. Split long files

My algorithmCombination project started as one gigantic header. 800 lines. Finding anything was pain.

Now I split by topic:

math_utils.h      // gcd, lcm, fast_pow
string_utils.h    // split, trim, join
data_structures.h // heap, disjoint_set

Each file is under 150 lines. I know exactly where everything lives.

6. The 30-second test

Six months from now, can I look at a random function and understand it in 30 seconds?

If yes: it's good code, even if it's not elegant.

If no: rename things, add one comment, split one function. Repeat until it passes.

I don't write code for the compiler. I write it for the version of me who hasn't slept and needs to fix a bug at midnight.

My GitHub: https://github.com/Cn-Alanwu

What Can You Actually Build With Just C++? — A Student's Perspective

Yilong Wu — Tue, 21 Jul 2026 03:22:52 +0000

Hi everyone! I'm AlanWu, a junior high school student from China. When I tell classmates I'm learning C++, the most common reaction is: "Oh, that black terminal thing?" They think C++ is just for boring console programs and algorithm contests.

But C++ is everywhere. Here's a tour of what you can actually build — from the obvious to the surprising — and how you can start, all with just C++.

My GitHub: https://github.com/Cn-Alanwu

1. Command-Line Tools (The Obvious Starting Point)

Yes, terminal programs. But not boring ones. Here's what I've built and what you can build:

Ping tool — I actually built one. It constructs raw ICMP packets, sends them to a target, and measures round-trip time. It taught me networking fundamentals, socket programming, and binary protocol parsing. https://github.com/Cn-Alanwu/Ping

Mini file compression — Using Huffman coding or LZW. You read bytes from a file, build a frequency table, encode, and write out a smaller file. 200 lines of C++ and you've built something that makes files smaller.

A simple database — Not MySQL-level, but a program that stores key-value pairs in a file, with binary search for fast lookup. You learn about file I/O, binary formats, and indexing.

A text-based game — A dungeon crawler, a roguelike, or even a trading sim. The control panel is text, but the game logic can be deep. No graphics library needed.

These are the "boring" ones, but they're not boring when you build them yourself. They teach you how computers actually work.

2. Desktop GUI Applications

Contrary to what many beginners think, C++ has GUI frameworks. You don't need Python or JavaScript for a window with buttons.

Qt — This is the big one. Qt is a cross-platform framework used by professional software like Autodesk Maya, VirtualBox, and Telegram Desktop. It has a visual designer where you drag and drop buttons, and you connect them to C++ code.

#include <QApplication>
#include <QLabel>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    QLabel label("Hello from C++ GUI!");
    label.show();
    return app.exec();
}

wxWidgets — Another cross-platform option, lighter than Qt. Good if you want something simpler.

FLTK — Extremely lightweight. For small utilities where you just need a few buttons and input fields.

imgui — Unlike the others, imgui is "immediate mode." You describe the UI in your game loop, and it renders directly. It's used heavily in game development tools and debug overlays.

Real example: the Unreal Engine editor interface? Built with C++ and a GUI framework derived from wxWidgets. The software you use to make games is itself made with C++.

3. Game Development (The Fun Part)

This is what got me interested in C++ in the first place. The vast majority of AAA games — Elden Ring, Cyberpunk 2077, Call of Duty — are built with C++. Why? Speed and control.

Where to start:

SFML — Simple and Fast Multimedia Library. Perfect for beginners. It handles windows, graphics, sound, and input. Here's a window with a circle:

#include <SFML/Graphics.hpp>

int main() {
    sf::RenderWindow window(sf::VideoMode(800, 600), "My Game");
    sf::CircleShape circle(50);
    circle.setFillColor(sf::Color::Green);

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed)
                window.close();
        }
        window.clear();
        window.draw(circle);
        window.display();
    }
    return 0;
}

SDL2 — Older than SFML but still widely used. It's the foundation of Valve's Source 2 engine (CS2, Dota 2).

Raylib — A newer, simpler library that's become very popular with hobbyists. Great for learning game programming concepts without boilerplate.

Unreal Engine — Uses C++ as its primary language. If you want to make 3D games professionally, Unreal + C++ is the path.

Godot with GDExtension — Godot is often associated with its own scripting language (GDScript), but you can write performance-critical modules in C++ via GDExtension.

4. Operating Systems and System Software

This sounds intimidating, but it's where C++ truly shines. The Linux kernel is C (not C++), but a huge amount of system software around it is C++:

Windows itself — Large parts of the Windows operating system, including the Windows shell, are written in C++
macOS/iOS kernel (XNU) — Partly C++
File systems — NTFS-3G (open-source NTFS driver) is C++
Device drivers — Many hardware drivers on Windows are C++

For a student, writing a tiny kernel or an OS module is a common university project. It teaches you about memory management, interrupts, and process scheduling at the lowest level.

5. Embedded Systems and IoT

C++ is the dominant language for embedded devices. Not the tiny 8-bit microcontrollers (those are usually C), but anything with a real operating system:

Arduino (official libraries) — Arduino's core libraries are a mix of C and C++. When you write Serial.println("hello"), you're calling C++ methods.
ESP32 / ESP8266 — These Wi-Fi microcontrollers support C++ with the Arduino framework or ESP-IDF. You can build a smart home sensor in 100 lines of C++.
Raspberry Pi — Running Linux, so you can use full C++17 on a $35 computer. Robotics, home automation, DIY gadgets.
Automotive — The software in your car's ECU (Engine Control Unit) and infotainment system? Heavily C++.
Drones and flight controllers — ArduPilot (open-source autopilot) is C++.

If it has a battery, a processor, and needs to be fast and reliable, it's probably running C++ somewhere.

6. Web Browsers

This one surprised me. The browsers you use every day have their core engines written in C++:

Chrome (Blink rendering engine + V8 JavaScript engine) — Both C++
Firefox (Gecko rendering engine + SpiderMonkey JS engine) — Both C++
Safari (WebKit) — C++

When JavaScript runs in your browser, it's being compiled on-the-fly by a C++ engine. Every DOM manipulation you do in JS eventually calls C++ code that paints pixels on your screen.

As a student, you can compile Chromium from source — yes, it takes hours — and explore how a real-world, massive C++ project is structured.

7. Databases

Most of the databases that power the internet are C++:

MySQL — The most popular open-source relational database. Core in C/C++.
MongoDB — A NoSQL document database. Written in C++.
Redis — The in-memory data structure store. Mostly C, but with C++ components.
RocksDB — Facebook's embedded key-value store. Pure C++. Used inside MySQL, MongoDB, and many others.

For learning, you can build a tiny database in 300 lines of C++ — an append-only log with a B-tree index. You'll understand how SQLite or RocksDB works at a fundamental level.

8. Programming Languages and Compilers

This is meta: use C++ to build tools that process other programming languages.

LLVM/Clang — The compiler infrastructure that powers the C, C++, and Objective-C compilers in Xcode, Android NDK, and many others. Written entirely in C++.
V8 — Google's JavaScript engine (used in Chrome and Node.js). C++.
SWIFT compiler — Apple's Swift language compiler. C++.

As a learning project, writing a tiny interpreter in C++ — a calculator that parses 3 + 4 * 5 and outputs 23 — teaches lexing, parsing, and abstract syntax trees. Scale that up and you have the foundation of a compiler.

9. Audio and Video Processing

Real-time audio and video processing needs speed. That means C++.

FFmpeg — The universal media processing tool used by VLC, YouTube, and countless others. Over 1 million lines of C.
Audacity — The open-source audio editor. C++.
OBS Studio — The streaming software used by millions of creators. C++ with Qt for the UI.
DAWs (Digital Audio Workstations) — Ableton Live, Logic Pro, FL Studio — their audio engines are C++.

You can start small: write a program that reads a WAV file, applies a reverb effect, and writes it back. Audio programming has a steep learning curve, but it's incredibly satisfying.

10. High-Frequency Trading and Finance

Not something I've done, but it's worth mentioning because it shows where C++ is irreplaceable. Trading firms use C++ because every microsecond matters:

Stock exchanges write their matching engines in C++.
Trading algorithms that process market data and make decisions in nanoseconds.
Bloomberg Terminal — the backend is heavily C++.

A college friend of mine interned at a trading firm. His interview question? Implement a lock-free queue in C++. That's the level of performance they're optimizing for.

What Should You Build First? (My Opinion)

As a student, here's my recommended path from "I know C++ syntax" to "I can build real things":

A command-line tool (like my Ping) — Teaches you that code can interact with the outside world.
A simple 2D game with Raylib or SFML — Teaches event loops, rendering, and game design.
A desktop utility with Qt — Say, a Markdown editor or a password generator GUI.
A small database engine — Teaches persistence, indexing, and data structures in practice.
Something embedded — An Arduino project that reads a sensor and lights an LED. C++ controlling physical things is an amazing feeling.

Each step builds on the last. And you'll never again hear "C++ is just terminal programs."

C++ isn't just a language. It's a passport to every corner of computing — from the pixels on your screen to the engines in your car. The only limit is how much you're willing to learn.

GitHub: https://github.com/Cn-Alanwu

Tags: #cpp #beginners #programming #gamedev #embeddedsystems #career #tutorial

C++ struct vs class — The Only Difference That Matters (Plus Real Use Cases)

Yilong Wu — Mon, 20 Jul 2026 02:38:46 +0000

Hi everyone! I'm AlanWu, a junior high school C++ learner. When I first saw both struct and class in C++, I was confused. I thought struct was just a C thing — a bag of variables with no functions. But in C++, you can put methods, constructors, inheritance — everything — in a struct.

So what's the actual difference? Here's the one-sentence answer, plus practical guidance on when to use which.

My GitHub: https://github.com/Cn-Alanwu

The One-Sentence Difference

In C++, struct and class are identical in every way — except the default access level: struct members are public by default; class members are private by default.

That's it. Everything else — inheritance, constructors, destructors, member functions, templates, virtual functions — works exactly the same in both.

struct S {
    int x;  // public by default
};

class C {
    int x;  // private by default
};

int main() {
    S s;
    s.x = 5;   // OK — public

    C c;
    // c.x = 5;  // ERROR — private
    return 0;
}

If you add public: to the class, the two become completely identical:

class C {
public:
    int x;  // now public — exactly like struct
};

The Inheritance Difference (Same Rule)

The same access rule applies to inheritance:

struct Base {};
struct Derived : Base {};  // public inheritance by default

class Base2 {};
class Derived2 : Base2 {};  // private inheritance by default

This means if you use class and forget to write public before the base class name, you get private inheritance — which is almost never what you want. It's a common beginner trap.

class Animal {
public:
    void eat() {}
};

// WRONG — private inheritance by default
class Dog : Animal {
};

int main() {
    Dog d;
    // d.eat();  // ERROR — eat() is private in Dog
    return 0;
}

// FIXED
class Dog : public Animal {
};

So When Do I Use Which?

After a year of C++, here's my personal rule — and it's not about the technical difference at all. It's about what you're communicating to other programmers.

Use `struct` when:

It's a simple data container — just a bundle of related values
All members can safely be public
There's no invariant to protect (no rule like "age must be positive")
Examples: a point (x, y), a configuration settings bundle, a return value from a function

struct Point {
    double x, y;
};

struct Config {
    int width;
    int height;
    bool fullscreen;
};

// struct is great for returning multiple values
struct SearchResult {
    bool found;
    int index;
    std::string message;
};

SearchResult find(const std::vector<int>& v, int target) {
    for (size_t i = 0; i < v.size(); i++) {
        if (v[i] == target) return {true, (int)i, "Found"};
    }
    return {false, -1, "Not found"};
}

Use `class` when:

You want encapsulation — hiding internal data behind methods
There's an invariant to protect (like "balance never goes below zero")
You expect the internal representation to change later
You're building something with behavior, not just data

class BankAccount {
private:
    double balance = 0.0;

public:
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }

    bool withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }

    double getBalance() const {
        return balance;
    }
};

Real Example from My Project: algorithmCombination

In my header-only algorithm library, I use struct and class side by side:

// struct — pure data, no invariants
template<typename T>
struct Pair {
    T first, second;
};

// class — has behavior, needs encapsulation
template<typename T>
class Stack {
private:
    std::vector<T> data;

public:
    void push(const T& val) {
        data.push_back(val);
    }

    T pop() {
        if (data.empty()) throw std::runtime_error("Stack is empty");
        T val = data.back();
        data.pop_back();
        return val;
    }

    bool empty() const { return data.empty(); }
    size_t size() const { return data.size(); }
};

The Pair is just two values glued together — struct. The Stack has rules (can't pop when empty) — class.

What About C Compatibility?

If you're writing a header that might be included in C code, use struct — C doesn't have class. But if you're writing pure C++ (which most of us are), C compatibility is rarely a concern.

// C-compatible
struct Point {
    double x, y;
};
// Works in both C and C++

// C++ only
class Point {
public:
    double x, y;
    double distance() const { return sqrt(x*x + y*y); }
};
// C can't use this — it has a member function

Summary Table

Feature	`struct`	`class`
Default member access	`public`	`private`
Default inheritance	`public`	`private`
Can have methods?	Yes	Yes
Can have constructors?	Yes	Yes
Can use virtual functions?	Yes	Yes
Can use templates?	Yes	Yes
Conventional use	Plain data bundles	Encapsulated objects

The Real Takeaway

Don't overthink this. If you're coming from C, struct feels natural for data. If you're coming from Java, class feels natural for everything. Both are correct — just be consistent.

In my projects, I follow this rule: if all members are public and there are no invariants, I use struct. If anything is private or needs protection logic, I use class. That's it.

The compiler doesn't care. But whoever reads your code six months later (including you) will appreciate the signal.

GitHub: https://github.com/Cn-Alanwu

C++ I/O Optimization for Competitive Programming — Fast Read, Fast Write, and More

Yilong Wu — Sun, 19 Jul 2026 00:37:45 +0000

I'm AlanWu. I spent way too long on Luogu wondering why my solution was TLE even though the algorithm was right. Then I learned about I/O.

The two lines that fix 90% of it

ios::sync_with_stdio(false);
cin.tie(nullptr);

Put these at the top of main. That's it. You just made cin about as fast as scanf.

What they do: the first line unties C++ streams from C streams (so they don't sync buffers). The second line unties cin from cout (so cout doesn't flush before every cin). Together, reading 1 million ints drops from ~2 seconds to ~0.3.

endl is a trap

cout << x << endl;   // flushes every time — slow
cout << x << '\n';   // doesn't flush — fast

endl does '\n' AND flush. You almost never need the flush part during a contest. Use '\n'.

When you need even more speed: fast read

For problems with 10^6+ numbers, cin with sync off is still not enough. You need integer parsing by hand:

inline int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = x * 10 + (ch - '0');
        ch = getchar();
    }
    return x * f;
}

And a matching fast write:

inline void write(int x) {
    if (x < 0) putchar('-'), x = -x;
    if (x > 9) write(x / 10);
    putchar(x % 10 + '0');
}

Use these when every millisecond counts. Most problems don't need them.

freopen for local testing

Typing test cases by hand is slow. Use file redirection:

#ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

Now cin reads from input.txt and cout writes to output.txt when you compile with -DLOCAL. On the judge, LOCAL isn't defined, so it reads from stdin like normal. You never need to change your code between local testing and submission.

Speed tier summary

Method	1 million ints	When to use
`cin >> x` (no optimization)	~2.0s	Never for contests
`cin >> x` (sync off)	~0.3s	Default for most problems
`scanf("%d", &x)`	~0.3s	Same tier as optimized cin
`read()` (custom)	~0.15s	10^6+ integers, strict time limits

For 90% of competition problems, just the two lines + '\n' is enough.

My GitHub: https://github.com/Cn-Alanwu

C++ Error Messages Translated — 10 Common Compilation & Link Errors Explained

Yilong Wu — Fri, 17 Jul 2026 02:08:03 +0000

C++ Error Messages Translated — 10 Common Compilation & Link Errors Explained

Hi everyone! I'm AlanWu, a junior high school C++ learner. When I first started coding, I'd see a wall of red text in the terminal and my brain would just shut down. expected unqualified-id before '}' token — what does that even mean?

After a year of self-learning, I've probably seen every error C++ can throw at a beginner. Here are the 10 most common ones, translated into plain English (and Chinese), why they happen, and how to fix them.

My GitHub: https://github.com/Cn-Alanwu

Error 1: Missing Semicolon

What the compiler says:

error: expected ';' before 'return'
error: expected ';' before '}' token

What it actually means:
You forgot a semicolon at the end of the previous line.

Why it happens:
The compiler doesn't notice the missing semicolon until it hits the next line and sees something that shouldn't be there — like return or }.

int main() {
    int x = 5            // ← missing semicolon here
    return 0;            // compiler complains HERE
}

Fix: Add the semicolon on the line before the one mentioned in the error.

Error 2: Undeclared Identifier

What the compiler says:

error: 'cout' was not declared in this scope
error: 'vector' does not name a type
error: 'myVariable' was not declared in this scope

What it actually means:
You either forgot to #include the right header, or you're misspelled the variable/function name, or you're using a variable before declaring it.

int main() {
    cout << "hello";  // forgot #include <iostream> AND std::
    return 0;
}

Fix:

Check you've included the right header (<iostream> for cout, <vector> for vector)
Check your spelling — C++ is case-sensitive (MyVariable != myVariable)
Add std:: or using namespace std; (but never in a header file!)

Error 3: Unqualified-id Before Token

What the compiler says:

error: expected unqualified-id before '{' token
error: expected unqualified-id before 'if'

What it actually means:
You have a stray character or bracket mismatch — usually an extra } somewhere that closed off something too early.

int main() {       // OK
    int x = 5;
}}                  // extra } — the second one broke everything

Fix: Count your curly braces. In VS Code, click on { or } to highlight its match. The error line is often NOT where the real problem is — check lines above it.

Error 4: Undefined Reference

What the compiler/linker says:

undefined reference to 'myFunction()'
undefined reference to 'MyClass::doSomething()'

What it actually means:
You declared a function or promised it exists (in a header or with a forward declaration), but the linker can't find the actual definition anywhere.

// mymath.h
int add(int a, int b);  // declaration — I promise this exists

// main.cpp
#include "mymath.h"
int main() {
    add(3, 4);  // linker: where is add()???
    return 0;
}
// Forgot to compile mymath.cpp or forgot to write the definition!

Fix:

Make sure the .cpp file containing the function definition is being compiled
Check that the function name and parameters match between declaration and definition
If you're using a library, make sure you linked it (e.g., -lsfml-graphics)

Error 5: Multiple Definition

What the compiler/linker says:

error: multiple definition of 'add(int, int)'

What it actually means:
The same function or variable is defined more than once. Usually happens when you define a function in a header file without inline, and include that header in multiple .cpp files.

// mymath.h — WRONG
int add(int a, int b) {
    return a + b;
}
// Every .cpp that includes mymath.h gets its own copy — linker sees duplicates.

Fix:

Add inline to the function: inline int add(...) { ... }
Or move the definition to a .cpp file and keep only the declaration in the header

Error 6: No Matching Function

What the compiler says:

error: no matching function for call to 'myFunction(int, double)'
note: candidate: 'void myFunction(int, int)'
note: no known conversion from 'double' to 'int'

What it actually means:
You're calling a function with the wrong argument types. The compiler is telling you: "I found a function with a similar name, but the types don't match."

void print(int x, int y) { /* ... */ }

int main() {
    print(3, 4.5);  // 4.5 is double, not int
    return 0;
}

Fix: Read the note: lines carefully — they tell you what the function actually expects. Either convert your argument or write an overload.

Error 7: Segmentation Fault

What the compiler says:
(Nothing at compile time — it crashes at runtime.)

Segmentation fault (core dumped)

What it actually means:
Your program tried to access memory it doesn't own. The most common causes for beginners:

Accessing an array out of bounds
Dereferencing a null or dangling pointer
Accessing an element of an empty vector

std::vector<int> v = {1, 2, 3};
std::cout << v[10];  // out of bounds — segmentation fault (maybe)

int* p = nullptr;
*p = 5;  // dereferencing null pointer — definitely segmentation fault

Fix:

Use .at() instead of [] with vectors — it throws an exception with a clear message
Always check if a pointer is not null before using it
Use a debugger to find the exact line that crashed

Error 8: Invalid Use of Incomplete Type

What the compiler says:

error: invalid use of incomplete type 'class MyClass'

What it actually means:
The compiler knows a class exists (because of a forward declaration), but hasn't seen the full definition yet. You can use it as a pointer or reference, but not to access members or create an object.

class B;  // forward declaration — compiler knows B exists

class A {
    B b;  // ERROR: compiler doesn't know how big B is yet
};

Fix:

If you only need a pointer/reference, use B* b; or B& b;
If you need the full object, #include "b.h" instead of forward-declaring

Error 9: Ambiguous Overload

What the compiler says:

error: call of overloaded 'myFunction(int)' is ambiguous

What it actually means:
Multiple functions match your call equally well, and the compiler can't decide which one to use.

void func(int x) { }
void func(long x) { }
void func(float x) { }

int main() {
    func(5);  // ambiguous: 5 matches int, long, AND float
    return 0;
}

Fix:

Cast your argument to the exact type: func(static_cast<long>(5))
Or if you're the one who wrote the overloads, simplify them — too many similar overloads is usually a design issue

Error 10: Stray '\342' '\200' '\234' in Program

What the compiler says:

error: stray '\342' in program
error: stray '\200' in program
error: stray '\234' in program

What it actually means:
You copied code from a website or document, and invisible "smart quotes" (" and ") or other Unicode characters got pasted in. The C++ compiler only understands plain ASCII " and '.

std::cout << "hello";    // ← these are smart quotes — invisible to your eyes but NOT to the compiler

Fix:

Delete the line and retype the quotes manually
Paste code into Notepad first, then copy from Notepad into your editor (Notepad strips fancy characters)
In VS Code, enable "Render Whitespace" to see suspicious characters

Bonus: My Coping Strategy

When I see a huge error log, here's what I do:

Read only the FIRST error. The rest are often cascading from the first one. Fix the first, recompile, and half of them disappear.
Go to the line number. The compiler tells you which line triggered the error. Start there.
Look ABOVE that line. Missing semicolons, unclosed brackets — the actual bug is often on the previous line.
Search the error text online. I guarantee someone has seen it before.

These 10 errors cover maybe 80% of what you'll encounter in your first year of C++. After that, the compiler stops being scary and starts being helpful.

GitHub: https://github.com/Cn-Alanwu

Tags: #cpp #beginners #tutorial #debugging #programming #coding

C++ 报错信息翻译指南 — 最常见的 10 条编译/链接错误逐条拆解

大家好，我是 AlanWu，一名学 C++ 的初中生。刚开始学的时候，终端里刷出一大片红字，我的大脑直接就宕机了。expected unqualified-id before '}' token — 这到底在说什么？

自学一年，我大概把 C++ 能给新手的所有报错都见了一遍。以下是最常见的 10 条，翻译成人话，解释原因，给出修改方法。

我的 GitHub：https://github.com/Cn-Alanwu

错误 1：少写了分号

编译器说：

error: expected ';' before 'return'
error: expected ';' before '}' token

人话翻译：
你上一行漏写了一个分号。

为什么：
编译器发现分号丢了的时候已经读到下一行了，看到不该出现的 return 或 }，才报错。

int main() {
    int x = 5            // ← 这里漏了分号
    return 0;            // 编译器在这里报错
}

修改方法： 在报错行的上一行补上分号。

错误 2：未声明的标识符

编译器说：

error: 'cout' was not declared in this scope
error: 'vector' does not name a type
error: 'myVariable' was not declared in this scope

人话翻译：
要么忘了 #include 对应的头文件，要么打错了变量/函数名，要么没声明就用了。

int main() {
    cout << "hello";  // 忘了 #include <iostream>，也忘了 std::
    return 0;
}

修改方法：

检查有没有引入对应的头文件（cout 需要 <iostream>，vector 需要 <vector>）
检查拼写 — C++ 区分大小写
加上 std:: 或者写 using namespace std;（但头文件里千万别用后者）

错误 3：莫名其妙的符号

编译器说：

error: expected unqualified-id before '{' token
error: expected unqualified-id before 'if'

人话翻译：
花括号对不上了 — 通常是多打了一个 }，把不该结束的地方提前结束了。

int main() {       // OK
    int x = 5;
}}                  // 多了一个 } — 第二个把结构写崩了

修改方法： 数花括号。VS Code 里点击 { 或 } 会高亮它的配对。报错行通常不是 bug 真正所在 — 往上面几行找。

错误 4：未定义的引用

编译器/链接器说：

undefined reference to 'myFunction()'
undefined reference to 'MyClass::doSomething()'

人话翻译：
你在某个地方声明了一个函数（在头文件里，或者用前向声明），编译器信了。但链接的时候，搜遍所有编译好的文件都找不到这个函数的定义。

// mymath.h
int add(int a, int b);  // 声明 — "我保证有这个函数"

// main.cpp
#include "mymath.h"
int main() {
    add(3, 4);  // 链接器：add() 在哪？？？
    return 0;
}
// 忘了编译 mymath.cpp，或者忘了写函数体！

修改方法：

确认包含函数定义的 .cpp 文件也被编译了
检查声明和定义的函数名、参数类型是否完全一致
如果用的是第三方库，确认链接命令对了

错误 5：重复定义

编译器/链接器说：

error: multiple definition of 'add(int, int)'

人话翻译：
同一个函数或变量被定义了不止一次。最常见的情况：在头文件里直接写了函数定义（没有 inline），然后多个 .cpp 文件都 include 了这个头文件。

// mymath.h — 错误写法
int add(int a, int b) {
    return a + b;
}
// 每个引入 mymath.h 的 .cpp 都会拿到一份副本 — 链接器看到重复

修改方法：

给函数加 inline：inline int add(...) { ... }
或者把定义移到 .cpp，头文件里只保留声明

错误 6：找不到匹配的函数

编译器说：

error: no matching function for call to 'myFunction(int, double)'
note: candidate: 'void myFunction(int, int)'
note: no known conversion from 'double' to 'int'

人话翻译：
你调用函数时传的参数类型不对。编译器在说："我找到了一个名字类似的，但参数类型对不上。"

void print(int x, int y) { /* ... */ }

int main() {
    print(3, 4.5);  // 4.5 是 double，不是 int
    return 0;
}

修改方法： 认真看 note: 那几行 — 它们精确告诉了你函数实际期望什么类型。要么转换参数类型，要么写一个重载版本。

错误 7：段错误

编译器说：
（编译时不报错，运行时崩溃。）

Segmentation fault (core dumped)

人话翻译：
你的程序试图访问不属于它的内存。新手最常见的三种情况：

数组越界
解引用空指针或野指针
访问空的 vector 的元素

std::vector<int> v = {1, 2, 3};
std::cout << v[10];  // 越界 — 大概率段错误

int* p = nullptr;
*p = 5;  // 解引用空指针 — 一定段错误

修改方法：

对 vector 用 .at() 代替 [] — 越界会抛异常，信息更清楚
使用指针前先判空
用调试器定位到崩溃的具体行

错误 8：不完整类型的使用

编译器说：

error: invalid use of incomplete type 'class MyClass'

人话翻译：
编译器知道某个类存在（比如通过前向声明），但还没看到它的完整定义。你可以用它声明指针和引用，但不能访问成员或创建对象。

class B;  // 前向声明 — 告诉编译器 B 存在

class A {
    B b;  // 报错：编译器不知道 B 有多大
};

修改方法：

如果只需要指针或引用，用 B* b; 或 B& b;
如果需要完整对象，#include "b.h" 代替前向声明

错误 9：重载歧义

编译器说：

error: call of overloaded 'myFunction(int)' is ambiguous

人话翻译：
有多个函数都能匹配你的调用，编译器不知道选哪个。

void func(int x) { }
void func(long x) { }
void func(float x) { }

int main() {
    func(5);  // 歧义：5 同时匹配 int、long、float
    return 0;
}

修改方法：

显式转换参数：func(static_cast<long>(5))
如果你是函数的编写者，考虑简化重载 — 太多相似的重载通常是设计问题

错误 10：Stray 字符

编译器说：

error: stray '\342' in program
error: stray '\200' in program
error: stray '\234' in program

人话翻译：
你从网页或文档里复制代码时，把不可见的"智能引号"（" "）或其他 Unicode 字符也复制进来了。C++ 编译器只认 ASCII 的直引号 " 和 '。

std::cout << "hello";    // ← 这是智能引号 — 肉眼看不出来，编译器看得一清二楚

修改方法：

删掉那行，手动敲一遍引号
先把代码粘贴到记事本，再从记事本复制到编辑器（记事本会去掉花哨字符）
VS Code 里打开"渲染空白字符"可以看到可疑的符号

附赠：我的应对策略

每次看到一大片报错，我这样做：

只看第一个错误。 后面的往往是连锁反应。修掉第一个，重新编译，一半报错直接消失。
跳到对应行号。 编译器告诉了你哪一行触发了错误，先去看那一行。
往上一行看。 漏分号、少括号 — 真正的 bug 通常在报错行的上一行。
把报错信息复制到网上搜。 我保证你不是第一个遇到的人。

这 10 条错误覆盖了 C++ 第一年可能会遇到的 80%。之后你就会发现：编译器不可怕，它其实是在帮你。

GitHub： https://github.com/Cn-Alanwu

标签： #cpp #beginners #tutorial #debugging #programming #coding

C++ Standard Library Hidden Gems — 6 Headers You're Probably Overlooking

Yilong Wu — Thu, 16 Jul 2026 08:21:02 +0000

Hi everyone! I'm AlanWu, a junior high school C++ learner. When I first started coding, I lived in two headers: #include <iostream> and #include <vector>. Everything else? I either didn't know it existed or assumed it was for "advanced programmers."

Turns out, the C++ standard library is full of tools that solve everyday problems in one line — I just never knew to look for them. Here are six that have saved me hours of writing unnecessary code.

My GitHub: https://github.com/Cn-Alanwu

1. `<numeric>` — Not Just Math, Actually Useful

Most beginners never include <numeric>. I didn't either — until I needed to compute a cumulative sum and wrote a 5-line loop. Then someone showed me:

#include <numeric>
#include <vector>

std::vector<int> v = {1, 2, 3, 4, 5};

// Sum all elements — no loop needed
int total = std::accumulate(v.begin(), v.end(), 0);  // 15

// Fill with sequential values
std::iota(v.begin(), v.end(), 1);  // v = {1, 2, 3, 4, 5} again

// GCD and LCM (C++17)
int g = std::gcd(12, 18);  // 6
int l = std::lcm(12, 18);  // 36

// Prefix sum — partial_sum produces {1, 3, 6, 10, 15}
std::vector<int> prefix(v.size());
std::partial_sum(v.begin(), v.end(), prefix.begin());

std::accumulate alone has probably saved me 50 lines of boilerplate. std::gcd and std::lcm replaced hand-written Euclidean algorithm functions I had copy-pasted across three projects.

2. `<algorithm>` — Beyond `sort()`, There's Gold

Everyone knows std::sort. But <algorithm> is massive, and some of its best tools are rarely taught:

#include <algorithm>
#include <vector>

std::vector<int> v = {5, 2, 9, 1, 5, 6};

// Find the 3rd smallest element (no full sort needed!)
std::nth_element(v.begin(), v.begin() + 2, v.end());
// v[2] is now the 3rd smallest; elements before are <=, after are >=

// All permutations (great for brute-force problems on Luogu!)
std::string s = "123";
do {
    std::cout << s << std::endl;  // prints 123, 132, 213, 231, 312, 321
} while (std::next_permutation(s.begin(), s.end()));

// Binary search on sorted ranges
bool found = std::binary_search(v.begin(), v.end(), 5);

// Rotate array elements
std::rotate(v.begin(), v.begin() + 2, v.end());
// {1, 2, 3, 4, 5} -> {3, 4, 5, 1, 2}

std::next_permutation is a cheat code for competitive programming brute-force problems. std::nth_element is O(n) — way faster than sorting the whole array when you only need one element.

3. `<string_view>` (C++17) — Avoid Unnecessary Copies

When you pass a string to a function, C++ usually copies it (or you use const std::string& and hope the caller has a std::string). What if the caller has a const char* or a substring?

#include <string_view>
#include <iostream>

// Works with std::string, const char*, and substrings — zero copies!
void print_first_word(std::string_view text) {
    auto pos = text.find(' ');
    std::cout << text.substr(0, pos) << std::endl;
}

int main() {
    std::string s = "hello world";
    print_first_word(s);                      // works
    print_first_word("goodbye world");        // works — no allocation!
    print_first_word(s.substr(0, 5) + "!");   // works on substring
}

std::string_view is a lightweight, non-owning view into a string. It's essentially a pointer + length. No heap allocation, no copying. For read-only string parameters, there's almost no reason to use const std::string& anymore.

4. `<optional>` (C++17) — Functions That Might Fail, Without Exceptions

How do you write a function that "might not have an answer"? Without <optional>, beginners often return sentinel values like -1 or empty strings:

#include <optional>
#include <string>
#include <vector>

// Clean: no sentinel values, no exceptions
std::optional<int> find_index(const std::vector<int>& v, int target) {
    for (size_t i = 0; i < v.size(); i++) {
        if (v[i] == target) return i;
    }
    return std::nullopt;  // "no answer"
}

// Usage
auto idx = find_index({3, 1, 4, 1, 5}, 4);
if (idx) {
    std::cout << "Found at: " << *idx << std::endl;  // 2
} else {
    std::cout << "Not found" << std::endl;
}

// Or use value_or() for defaults
int position = find_index({3, 1, 4, 1, 5}, 99).value_or(-1);  // -1

This replaces the "is this return value valid?" guessing game with a type-safe approach. The compiler forces you to check before using the value.

5. `<bitset>` — Bit Manipulation Without Headaches

Bit operations are common in competitive programming (set representation, DP state compression, flags). The manual way with <<, >>, &, | is error-prone:

#include <bitset>
#include <iostream>

// Fixed-size bit array — operations read like English
std::bitset<8> bits("10110011");

std::cout << bits.count() << std::endl;    // 5 (number of 1s)
std::cout << bits.test(3) << std::endl;    // 0 (bit at position 3)
std::cout << bits.any() << std::endl;      // true (at least one 1?)

bits.set(0, true);   // set bit 0 to 1
bits.flip(2);        // toggle bit 2
bits.reset(7);       // set bit 7 to 0

std::cout << bits.to_ullong() << std::endl; // convert to unsigned long long
std::cout << bits.to_string() << std::endl; // back to string "00110011"

srd::bitset handles boundary checks and conversion, and the .count() method is internally optimized. For bit DP problems on Luogu, this is a lifesaver.

6. `<tuple>` + Structured Bindings (C++17) — Return Multiple Values Cleanly

Returning multiple values from a function used to mean either std::pair (only two values) or std::tuple with verbose std::get<>():

#include <tuple>
#include <iostream>

// Return three values naturally
std::tuple<int, double, std::string> get_stats() {
    return {42, 3.14, "hello"};
}

int main() {
    // C++17 structured binding — auto unpacking!
    auto [count, pi, message] = get_stats();
    std::cout << count << ", " << pi << ", " << message << std::endl;
    // 42, 3.14, hello

    // std::tie for existing variables (works in C++11)
    int a;
    double b;
    std::string c;
    std::tie(a, b, c) = get_stats();
}

Structured bindings work with structs, pairs, tuples, and arrays. Combined with std::map::insert (which returns pair<iterator, bool>), this pattern appears everywhere in modern C++.

Quick Reference

Header	Must-Try
`<numeric>`	`accumulate`, `gcd`, `iota`, `partial_sum`
`<algorithm>`	`next_permutation`, `nth_element`, `rotate`, `binary_search`
`<string_view>`	Non-owning string parameter — zero-copy
`<optional>`	`value_or()`, `has_value()`, `std::nullopt`
`<bitset>`	`count()`, `set()`, `flip()`, `to_string()`
`<tuple>`	Structured bindings: `auto [a, b, c] = ...`

None of these are "advanced." They're just standard tools that most tutorials skip over because they'd rather teach you to write a swap function by hand. Next time you find yourself writing a loop for something that feels like it should be built-in — it probably is.

GitHub: https://github.com/Cn-Alanwu

Tags: #cpp #beginners #tutorial #programming #cpp17 #stl

C++ 标准库里的宝藏 — 6 个你可能忽略但超实用的头文件

大家好，我是 AlanWu，一名学 C++ 的初中生。刚入门的时候，我的代码基本只有两个头文件：#include <iostream> 和 #include <vector>。其他的？要么不知道存在，要么以为那是"大佬"才用的。

后来才发现，C++ 标准库里有大量一行代码就能解决日常需求的工具。下面这 6 个帮我省了无数手写代码的时间。

我的 GitHub：https://github.com/Cn-Alanwu

1. `<numeric>` — 不只是数学，是真的好用

初学者几乎没人 include <numeric>。我也是，直到有一次需要算前缀和，自己写了 5 行循环，然后别人给我看了这个：

#include <numeric>
#include <vector>

std::vector<int> v = {1, 2, 3, 4, 5};

// 求和 — 不用写循环
int total = std::accumulate(v.begin(), v.end(), 0);  // 15

// 填连续值
std::iota(v.begin(), v.end(), 1);  // v 恢复到 {1, 2, 3, 4, 5}

// 最大公约数和最小公倍数（C++17）
int g = std::gcd(12, 18);  // 6
int l = std::lcm(12, 18);  // 36

// 前缀和 — partial_sum 输出 {1, 3, 6, 10, 15}
std::vector<int> prefix(v.size());
std::partial_sum(v.begin(), v.end(), prefix.begin());

光 std::accumulate 一个函数就省掉了我至少 50 行样板代码。std::gcd 和 std::lcm 直接替代了我之前在三个项目里复制粘贴的手写欧几里得算法。

2. `<algorithm>` — 除了 `sort()`，宝藏太多了

大家都知道 std::sort。但 <algorithm> 这个头文件超大，里面很多好用的东西根本没人在入门教程里讲：

#include <algorithm>
#include <vector>

std::vector<int> v = {5, 2, 9, 1, 5, 6};

// 找第 3 小的元素（O(n)，不用全排序！）
std::nth_element(v.begin(), v.begin() + 2, v.end());
// v[2] 现在是第 3 小，它左边的都 <= 它，右边的都 >= 它

// 全排列生成（洛谷暴力枚举题的作弊码！）
std::string s = "123";
do {
    std::cout << s << std::endl;  // 输出 123, 132, 213, 231, 312, 321
} while (std::next_permutation(s.begin(), s.end()));

// 有序区间的二分查找
bool found = std::binary_search(v.begin(), v.end(), 5);

// 旋转数组
std::rotate(v.begin(), v.begin() + 2, v.end());
// {1, 2, 3, 4, 5} → {3, 4, 5, 1, 2}

std::next_permutation 对于洛谷上那些需要枚举所有排列的暴力题简直是外挂。std::nth_element 只需要 O(n) —— 当你只需要某个位置的值时，比全排序快多了。

3. `<string_view>`（C++17）— 告别不必要的字符串拷贝

把字符串传给函数，C++ 默认会拷贝一份（要么你用 const std::string&，还得指望调用方刚好有 std::string）。如果调用方只有一个 const char* 或者子串呢？

#include <string_view>
#include <iostream>

// 能接受 std::string、const char*、子串 — 全部零拷贝！
void print_first_word(std::string_view text) {
    auto pos = text.find(' ');
    std::cout << text.substr(0, pos) << std::endl;
}

int main() {
    std::string s = "hello world";
    print_first_word(s);                      // OK
    print_first_word("goodbye world");        // OK — 没有内存分配！
    print_first_word(s.substr(0, 5) + "!");   // 子串也 OK
}

std::string_view 是一个轻量的、不拥有数据的字符串视图，本质上就是指针+长度。没有堆分配，没有拷贝。对于只需要读字符串的参数，几乎没有理由继续用 const std::string& 了。

4. `<optional>`（C++17）— 函数可能没结果，不用抛异常

怎么表示一个函数"可能没有答案"？没有 <optional> 的时候，新手通常返回哨兵值，比如 -1 或空字符串：

#include <optional>
#include <string>
#include <vector>

// 干净：不用哨兵值，不用异常
std::optional<int> find_index(const std::vector<int>& v, int target) {
    for (size_t i = 0; i < v.size(); i++) {
        if (v[i] == target) return i;
    }
    return std::nullopt;  // 表示"没有答案"
}

// 使用
auto idx = find_index({3, 1, 4, 1, 5}, 4);
if (idx) {
    std::cout << "找到，位置：" << *idx << std::endl;  // 2
} else {
    std::cout << "没找到" << std::endl;
}

// 或者用 value_or() 给默认值
int position = find_index({3, 1, 4, 1, 5}, 99).value_or(-1);  // -1

它把"返回值到底有没有效"这个猜谜游戏变成了类型安全的检查。编译器会逼着你先判断再用，不会让你忘。

5. `<bitset>` — 位操作不头疼

位运算在算法竞赛里很常见（集合表示、DP 状态压缩、标记位）。手动用 <<、>>、&、| 写很容易出错：

#include <bitset>
#include <iostream>

// 固定大小的位数组 — 操作读起来像英语
std::bitset<8> bits("10110011");

std::cout << bits.count() << std::endl;    // 5（1 的个数）
std::cout << bits.test(3) << std::endl;    // 0（第 3 位是 0）
std::cout << bits.any() << std::endl;      // true（至少一个 1？）

bits.set(0, true);   // 第 0 位设为 1
bits.flip(2);        // 第 2 位翻转
bits.reset(7);       // 第 7 位清零

std::cout << bits.to_ullong() << std::endl; // 转成 unsigned long long
std::cout << bits.to_string() << std::endl; // 转回字符串 "00110011"

std::bitset 自动处理边界检查，.count() 方法内部是优化过的。洛谷上的状态压缩 DP 题，有它省心太多。

6. `<tuple>` + 结构化绑定（C++17）— 干净地返回多个值

函数返回多个值，以前要么用 std::pair（只能两个值），要么用 std::tuple 再配上一堆啰嗦的 std::get<>()：

#include <tuple>
#include <iostream>

// 自然返回三个值
std::tuple<int, double, std::string> get_stats() {
    return {42, 3.14, "hello"};
}

int main() {
    // C++17 结构化绑定 — 自动解包！
    auto [count, pi, message] = get_stats();
    std::cout << count << ", " << pi << ", " << message << std::endl;
    // 42, 3.14, hello

    // std::tie 用于已有变量（C++11 就支持）
    int a;
    double b;
    std::string c;
    std::tie(a, b, c) = get_stats();
}

结构化绑定适用于 struct、pair、tuple 和数组。配合 std::map::insert（返回 pair<iterator, bool>），这个写法在现代 C++ 里随处可见。

速查表

头文件	必试函数
`<numeric>`	`accumulate`、`gcd`、`iota`、`partial_sum`
`<algorithm>`	`next_permutation`、`nth_element`、`rotate`、`binary_search`
`<string_view>`	非拥有型字符串参数，零拷贝
`<optional>`	`value_or()`、`has_value()`、`std::nullopt`
`<bitset>`	`count()`、`set()`、`flip()`、`to_string()`
`<tuple>`	结构化绑定：`auto [a, b, c] = ...`

这些东西没有一个是"高级"的，它们只是标准库里被大多数入门教程跳过的好工具——因为教程宁愿教你手写 swap 也不提这些。下次当你发现自己又在写循环实现某个功能，感觉这应该有人写好了的话 — 它大概率确实有人写好了，就在标准库里。

GitHub： https://github.com/Cn-Alanwu

3 C++ Projects I Built as a Junior High Student — Full Source Code on GitHub

Yilong Wu — Wed, 15 Jul 2026 08:23:31 +0000

Hi everyone! My name is AlanWu. I'm an ordinary junior high school student in China, and I love coding in C++. I know my programming skills aren't perfect yet, but I believe sharing and getting feedback is the best way to grow. Here are three open-source C++ projects I built — feedback and contributions are always welcome!

Ping — A Lightweight ICMP Ping Tool

GitHub: https://github.com/Cn-Alanwu/Ping

Tech Stack: C++, Raw Sockets, ICMP Protocol

A simple local network ping program implemented from scratch using raw sockets and the ICMP protocol. Instead of just calling the system's built-in ping command, this project shows exactly how ping works under the hood — packet construction, checksum calculation, round-trip time measurement, and TTL handling.

Key Features:

Sends ICMP Echo Request packets and receives Echo Reply

Calculates RTT (round-trip time) in milliseconds

Supports configurable packet size and timeout

Clean, well-commented C++ code suitable for learning

Why It Matters: If you're learning network programming or socket APIs, reading a real implementation is far better than just reading theory. This project is small enough to understand in one sitting.

luogu-answer — Algorithm Problem Solutions for Luogu

GitHub: https://github.com/Cn-Alanwu/luogu-answer

Tech Stack: C++, Algorithms & Data Structures

A growing collection of reference answers (in C++) for algorithm problems on Luogu, one of China's largest online judge platforms for competitive programming. Each solution includes the problem ID and is ready to submit — just copy, paste, and it passes the judge.

Topics Covered:

Dynamic Programming

Graph Theory (DFS, BFS, shortest paths, MST)

Data Structures (segment tree, union-find, Fenwick tree)

Number Theory & Combinatorics

String Algorithms

Why It Matters: When you're stuck on a Luogu problem at 2 AM, having a clean reference solution to compare against is a lifesaver. This repo is my personal problem-solving journal — use it as a study companion.

algorithmCombination — Header-Only C++ Algorithm Library

GitHub:https://github.com/Cn-Alanwu/algorithmCombination

Tech Stack: C++ (Header-Only), Templates

A collection of commonly used algorithm and data structure templates, packaged as standalone header files with bilingual (Chinese + English) documentation. Header-only means zero configuration — just #include and start coding.

What's Inside:

Sorting algorithms (quick sort, merge sort, heap sort)

Graph algorithms (Dijkstra, Kruskal, Floyd-Warshall)

Math utilities (fast power, GCD/LCM, prime sieve)

Data structures (binary indexed tree, segment tree, disjoint set)

Why It Matters: In competitive programming, every second counts. Having battle-tested algorithm templates ready to go can be the difference between AC and TLE. The bilingual comments also make it friendly for both Chinese and English-speaking learners.

Wrapping Up

I built these projects because I genuinely enjoy writing code and solving problems. They're not perfect — I'm still learning, and I know there are bugs and room for improvement. If you find something wrong, please open an issue or even better, send a pull request. I'd love to learn from you.

If any of these projects help you even a little, a ⭐ on GitHub would mean a lot to me.

My GitHub: https://github.com/Cn-Alanwu

Tags: #cpp #github #opensource #programming #algorithms #networking #beginners #competitiveprogramming

中文版

大家好，我是AlanWu，一名普通的中国初中生，平时喜欢用 C++ 写代码。虽然我写的不算好，但我相信多分享、多接受反馈才能进步。以下是我写的三个 C++ 开源项目，欢迎大家提意见和 Pull Request！

Ping — 轻量级 ICMP Ping 工具

仓库： https://github.com/Cn-Alanwu/Ping

技术栈： C++, Raw Socket, ICMP 协议

从零实现的本地网络 Ping 程序，使用原始套接字直接构造 ICMP 报文。不是调用系统自带的 ping 命令，而是从底层展示了 Ping 的工作原理：报文构造、校验和计算、往返时间测量、TTL 处理等。

核心特性：

发送 ICMP 回显请求、接收回显应答

计算并显示毫秒级 RTT 延迟

支持自定义包大小和超时时间

代码简洁，注释清晰，适合网络编程入门学习

luogu-answer — 洛谷算法题参考答案

仓库： https://github.com/Cn-Alanwu/luogu-answer

技术栈： C++，算法与数据结构

收集了洛谷在线判题平台上部分题目的 C++ 参考题解，每道题附带题目编号，代码可直接提交通过评测。

覆盖主题：

动态规划、图论（DFS/BFS/最短路/最小生成树）

数据结构（线段树、并查集、树状数组）

数论与组合数学、字符串算法

algorithmCombination — C++ 算法头文件库

仓库： https://github.com/Cn-Alanwu/algorithmCombination

技术栈： C++（Header-Only），模板

将常用算法和数据结构模板封装为独立头文件，中英双语注释，Header-Only 即插即用。目前包含排序、图论、数学工具、数据结构等常用模板。

如果这些项目对你有帮助，欢迎点个 Star ⭐，也欢迎提 Issue 和 PR 一起改进！

DEV Community: Yilong Wu

My STL Post Sparked a Real Discussion — Here's Where It Landed

The argument, summarized

Where I agree

Where I still disagree (respectfully)

The middle ground

Someone Commented on My STL Post — Here's the Follow-Up

The problem

The right tool exists

The full move logic

Why this matters

Stop Using Arrays for Everything

vector — your new default

map — when you need to look stuff up by name

unordered_map — same thing, but faster (usually)

set — when you only care if something exists

The actual decision tree

The one you probably don't need: deque

Bottom line

Write Code You Can Still Read 6 Months Later

1. Name things like a human

2. Functions should do one thing

3. Comments explain WHY, not WHAT

4. Don't nest too deep

5. Split long files

6. The 30-second test

What Can You Actually Build With Just C++? — A Student's Perspective

1. Command-Line Tools (The Obvious Starting Point)

2. Desktop GUI Applications

3. Game Development (The Fun Part)

4. Operating Systems and System Software

5. Embedded Systems and IoT

6. Web Browsers

7. Databases

8. Programming Languages and Compilers

9. Audio and Video Processing

10. High-Frequency Trading and Finance

What Should You Build First? (My Opinion)

C++ struct vs class — The Only Difference That Matters (Plus Real Use Cases)

The One-Sentence Difference

The Inheritance Difference (Same Rule)

So When Do I Use Which?

Use struct when:

Use class when:

Real Example from My Project: algorithmCombination

What About C Compatibility?

Summary Table

The Real Takeaway

C++ I/O Optimization for Competitive Programming — Fast Read, Fast Write, and More

The two lines that fix 90% of it

endl is a trap

When you need even more speed: fast read

freopen for local testing

Speed tier summary

C++ Error Messages Translated — 10 Common Compilation & Link Errors Explained

C++ Error Messages Translated — 10 Common Compilation & Link Errors Explained

Error 1: Missing Semicolon

Error 2: Undeclared Identifier

Error 3: Unqualified-id Before Token

Error 4: Undefined Reference

Error 5: Multiple Definition

Error 6: No Matching Function

Error 7: Segmentation Fault

Error 8: Invalid Use of Incomplete Type

Error 9: Ambiguous Overload

Error 10: Stray '\342' '\200' '\234' in Program

Bonus: My Coping Strategy

C++ 报错信息翻译指南 — 最常见的 10 条编译/链接错误逐条拆解

错误 1：少写了分号

错误 2：未声明的标识符

错误 3：莫名其妙的符号

错误 4：未定义的引用

错误 5：重复定义

错误 6：找不到匹配的函数

错误 7：段错误

错误 8：不完整类型的使用

错误 9：重载歧义

错误 10：Stray 字符

附赠：我的应对策略

C++ Standard Library Hidden Gems — 6 Headers You're Probably Overlooking

Use `struct` when:

Use `class` when:

1. `<numeric>` — Not Just Math, Actually Useful

2. `<algorithm>` — Beyond `sort()`, There's Gold

3. `<string_view>` (C++17) — Avoid Unnecessary Copies

4. `<optional>` (C++17) — Functions That Might Fail, Without Exceptions

5. `<bitset>` — Bit Manipulation Without Headaches

6. `<tuple>` + Structured Bindings (C++17) — Return Multiple Values Cleanly

1. `<numeric>` — 不只是数学，是真的好用

2. `<algorithm>` — 除了 `sort()`，宝藏太多了

3. `<string_view>`（C++17）— 告别不必要的字符串拷贝

4. `<optional>`（C++17）— 函数可能没结果，不用抛异常

5. `<bitset>` — 位操作不头疼

6. `<tuple>` + 结构化绑定（C++17）— 干净地返回多个值