C關於模板和通用編程的教程

C 模板通過編譯時類型替換實現泛型編程，減少重複邏輯。它分為函數模板與類模板，前者如template T add(T a, T b)可自動推導類型，後者如template class Box用於創建通用容器；模板參數不僅支持類型（typename T），也支持值（如template class StaticArray），且可混合使用；編寫模板時應從簡單入手，優先使用typename，注意錯誤定位困難及操作符有效性，C 20的Concepts可用於約束類型，提升代碼安全性和可讀性。

Templates in C are one of the most powerful tools for writing generic code — meaning you can write functions and classes that work with any data type, without duplicating logic. It's what makes things like std::vector or std::map possible, where they adapt to whatever type you throw at them.

What Are Templates?

At their core, templates let you define functions or classes using placeholder types. The compiler then generates the real code when it sees which types you're actually using.

For example:

 template <typename T>
T add(T a, T b) {
    return ab;
}

Here, T is a placeholder. When you call add<int>(1, 2) or add<double>(1.5, 2.3) , the compiler creates two separate versions of this function under the hood.

This is different from just using void* or inheritance-based polymorphism because templates are resolved at compile time — no runtime overhead.

Function Templates vs Class Templates

There are two main kinds of templates: function templates and class templates.

Function Templates

These are used to create families of functions. You've already seen a basic example above.

You don't always need to specify the template parameter explicitly. If the compiler can deduce it from the arguments, it will:

 int result = add(3, 4); // Compiler deduces T as int

But if your function doesn't use all parameters in a way that allows deduction (like if they're defaulted), you'll have to specify the type manually.

Class Templates

These are used when you want a class to work with different types. A classic example is a container:

 template <typename T>
class Box {
public:
    Box(T value) : value_(value) {}
    T get() const { return value_; }
private:
    T value_;
};

Then you can do:

 Box<int> intBox(42);
Box<std::string> stringBox("hello");

Just like with functions, the compiler creates a new version of the class for each type used.

Template Parameters: Types and Values

Templates aren't limited to just type parameters ( typename T ). You can also pass values as template parameters.

For example:

 template <int Size>
class StaticArray {
public:
    int data[Size];
};

Now you can do:

 StaticArray<10> arr; // Array of size 10 known at compile time

This is how fixed-size containers in libraries like Eigen or some embedded systems code work. These values must be known at compile time.

You can mix both type and value parameters:

 template <typename T, int N>
class ArrayWrapper {
    T data[N];
};

Tips for Writing Your Own Templates

• Start simple : Don't overcomplicate templates early on. Just replace hardcoded types with T .
• Use typename, not class : Both work, but typename is more general and preferred.
• Be careful with template instantiation errors : Since templates are compiled only when used, errors might pop up far from where you wrote the code.
• Avoid repeating yourself : If you find yourself writing nearly identical code for multiple types, templates are probably the solution.
• Don't assume operators exist : If your template uses , make sure the type actually supports it. Concepts (in C 20) help enforce these assumptions.

Concepts are a newer feature that lets you constrain what types can be used with a template:

 template <std::integral T>
T multiply(T a, T b) {
    return a * b;
}

This ensures only integer-like types can be passed into multiply .

Final Thoughts

Templates are what make C so flexible without sacrificing performance. They're a bit tricky to start with, especially when dealing with complex instantiations or error messages, but once you understand how they work, you'll wonder how you ever wrote code without them.

It's not magic — just the compiler doing work ahead of time. And that's kind of the whole point of C .

以上是C關於模板和通用編程的教程的詳細內容。更多資訊請關注PHP中文網其他相關文章！