C templates improve code reusability and efficiency through generic programming. Its core mechanism is to use type placeholders so that functions or classes can adapt to multiple data types. The specific points are as follows: 1. Function templates generate specific types of function instances to reduce duplicate code; 2. Class templates support multi-type implementations of data structures, such as std::vector; 3. Non-type parameters allow passing constant values ??or templates as parameters; 4. Pay attention to potential problems such as code bloating and complex error messages during compilation. Mastering templates can significantly enhance code flexibility and performance.

C templates are a powerful feature that allows you to write generic code, which can work with various data types without being rewriteten for each one. In short, templates let you define functions or classes that operate on placeholder types, which the compiler replaces with specific types when used in your program.

They're especially useful when you want the same logic to apply across different types — like containers (eg, std::vector ) or utility functions (like std::swap ) — while still keeping type safety and performance benefits of compiled code.

Here's how they work in practice:

Function Templates

A function template is a blueprint for generating functions based on the types passed to it.

For example:

 template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

You can call this function with any type that supports copy construction and assignment — like int , double , or even custom objects.

• The compiler automatically generates a version of the function for each type used.
• You don't have to manually overload the function for every type.
• It helps reduce relative code and increase maintenance.

Just keep in mind: if the type doesn't support all the operations used inside the template (like copying or comparison), you'll get a compiler error when it tries to instantiate the function.

Class Templates

Class templates are similar but apply to entire classes. They're commonly used for data structures that need to hold different types.

Take std::vector<T> as an example:

• It's a single class template that becomes a vector of int , string , or any user-defined type depending on how you declare it.
• You can define member functions inside the class template or outside using the template<> syntax.

When defining a class template, you typically include all the implementation in the header file because the compiler needs to see the full definition when instantiating the template for a specific type.

One thing to watch out for:

• Template instantiation can increase compile times and binary size since the compiler generates separate code for each type used.

Template Parameters Beyond Types

While most templates use type parameters ( typename T ), they can also take non-type parameters — like integers, points, or even other templates.

Example of a non-type parameter:

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

This lets you create arrays with a fixed size known at compile time. For instance:

• StaticArray gives you an array of 10 integers.
• StaticArray creates another with 100 elements.

Another advanced use is template template parameters — where a template takes another template as an argument. This is less common but handy when building flexible container wrappers or policy-based designs.

Common Pitfalls and Tips

Templates can be tricky if you're just starting out. Here are some things to keep in mind:

• Error messages from template code can be hard to read. Modern compilers have improved, but expect some complexity.
• Separating declaration and implementation in source files doesn't work the same way as regular code — usually everything goes in headers.
• Use typename and template keywords properly when dealing with nested dependent types.
• Avoid overusing templates where simpler solutions exist. Sometimes function overloading or polymorphism is better.

If you're new, start small — try writing a generic max function or a simple wrapper around a container before diving into more complex uses.

Basically that's it. Templates are a core part of modern C and give you a lot of flexibility without sacrificing performance. Once you get comfortable with the syntax and behavior, you'll find yourself using them more naturally in your code design.

The above is the detailed content of What are templates in C ?. For more information, please follow other related articles on the PHP Chinese website!