Penggunaan khas parameter lalai fungsi C++ dan parameter pembolehubah dalam pengaturcaraan templat

Penggunaan khas parameter lalai dan parameter pembolehubah dalam pengaturcaraan templat dalam C++: Parameter lalai membenarkan fungsi menggunakan nilai lalai apabila tiada parameter dinyatakan, dengan itu mencapai lebihan fungsi generik. Parameter pembolehubah membenarkan fungsi menerima sebarang bilangan parameter, mencapai kepelbagaian kod dan boleh digunakan untuk fungsi atau bekas generik yang mengendalikan sebarang bilangan parameter. Kes praktikal: Melaksanakan fungsi pemformatan perpuluhan umum, menggunakan parameter lalai untuk menentukan ketepatan yang berbeza untuk jenis perpuluhan yang berbeza.

Penggunaan khas parameter lalai fungsi C++ dan parameter pembolehubah dalam pengaturcaraan templat

Dalam pengaturcaraan templat C++, penggunaan parameter lalai dan parameter pembolehubah boleh meningkatkan kecekapan dan serba boleh kod. Mari kita terokai kegunaan istimewa mereka:

Parameter Lalai

Parameter lalai membenarkan parameter tertentu diabaikan semasa memanggil fungsi. Apabila parameter tidak ditentukan, nilai lalai digunakan. Contohnya:

template<typename T, typename U = T>
auto sum(T a, U b = 0) {
    return a + b;
}

Dalam contoh di atas, b ialah parameter lalai dengan nilai lalai 0. Kita boleh memanggil fungsi ini seperti ini: b 是一个默认参数，默认值为 0。我们可以像这样调用此函数：

int total = sum(10); // b 默认值为 0，结果为 10

可变参数

可变参数允许函数接收任意数量的参数。它们使用 ... 运算符表示。例如：

template<typename T>
auto print_all(T... args) {
    for (auto arg : {args...}) {
        std::cout << arg << ' ';
    }
    std::cout << '\n';
}

在这个示例中，args 是一个可变参数包，可以接收任意数量的 T

print_all(1, 2.5, "hello"); // 输出："1 2.5 hello"

Parameter variadik

template<typename T, typename D = char>
auto print_delimited(T value, D delimiter = ' ') {
    std::cout << value;
    if constexpr (std::is_same_v<D, char>) { // 如果分隔符为字符
        std::cout << delimiter;
    } else { // 如果分隔符为字符串
        std::cout << delimiter << '\n';
    }
}

Salin selepas log masuk
• Dalam contoh ini, args ialah pek argumen variadic yang boleh menerima sebarang bilangan argumen jenis T. Kita boleh memanggil fungsi ini seperti ini:

  template<typename T>
  auto sum_all(T... args) {
      return (... + args);
  }

  Salin selepas log masuk
Penggunaan khas dalam pengaturcaraan templat

• Penjanaan lebihan fungsi:
Parameter lalai boleh menyamaratakan fungsi terlampau beban, menghapuskan keperluan untuk kebergantungan parameter tertentu. Sebagai contoh, kami boleh menyediakan pelbagai jenis pemisah lalai dalam fungsi cetakan universal:

template<typename T, typename Alloc = std::allocator<T>>
class Vector {
public:
    Vector(T... args) {
        for (auto arg : {args...}) {
            emplace_back(arg);
        }
    }
};

Salin selepas log masuk
• Penjanaan bilangan parameter:
Parameter variadik membolehkan fungsi mengendalikan sebarang bilangan parameter, sekali gus mencapai kepelbagaian kod. Sebagai contoh, kita boleh menggunakan argumen variadic dalam fungsi jumlah yang menghantar sebarang bilangan argumen:

template<typename T, typename D = T, D precision = 2>
std::string format_float(T value) {
    std::stringstream ss;
    ss << std::fixed << std::setprecision(precision) << value;
    return ss.str();
}

Parameter lalai dan parameter variadic boleh memainkan peranan penting dalam penjanaan kontena. Sebagai contoh, kita boleh mencipta bekas generik yang jenis elemennya boleh disimpulkan daripada panggilan fungsi:

std::cout << format_float(3.14159265) << '\n'; // 输出："3.14" (默认精度为 2)
std::cout << format_float<float>(3.14159265, 6) << '\n'; // 输出："3.141593" (精度为 6)

Atas ialah kandungan terperinci Penggunaan khas parameter lalai fungsi C++ dan parameter pembolehubah dalam pengaturcaraan templat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!