Bolehkah Fungsi C Dibebankan Berdasarkan Nilai Pulangannya?

Fungsi Lebih Muatan Berdasarkan Nilai Pulangan dalam C

Fungsi lebih muatan berdasarkan parameter adalah amalan biasa dalam C . Walau bagaimanapun, lebihan beban berdasarkan nilai pulangan juga mungkin, membolehkan anda mencipta fungsi yang berkelakuan berbeza bergantung pada cara nilai pulangan digunakan.

Terdapat beberapa kaedah untuk mencapai ini:

Penaipan Panggilan Eksplisit

Gunakan jenis yang berbeza untuk literal yang dihantar ke fungsi. Contohnya, untuk fungsi mengembalikan integer atau rentetan bergantung pada penggunaan:

int mul(int, int);
std::string mul(char, int);

int n = mul(6, 3); // Function called with int return value
std::string s = mul('6', 3); // Function called with string return value

Pendekatan Penunjuk Dummy

Tambah parameter penunjuk tiruan pada setiap fungsi, memaksa pengkompil untuk memilih versi yang betul berdasarkan nilai pulangan jenis:

int mul(int*, int, int);
std::string mul(std::string*, char, int);

int n = mul((int*)NULL, 6, 3); // Function called with int return value
std::string s = mul((std::string*)NULL, '6', 3); // Function called with string return value

Pengkhususan Templat untuk Nilai Pulangan

Buat fungsi templat dan mengkhususkannya untuk jenis pulangan tertentu:

template<typename T>
T mul(int, int)
{
    // Generic function with a dummy member variable that will cause a compilation error
    // if not specialized
    const int k = 25;
    k = 36;
}

template<>
int mul<int>(int, int)
{
    return i * j;
}

template<>
std::string mul<std::string>(int, int)
{
    return std::string(j, static_cast<char>(i));
}

int n = mul<int>(6, 3); // Function called with int return value
std::string s = mul<std::string>('6', 3); // Function called with string return value

Kaedah ini memerlukan secara eksplisit menyatakan jenis pemulangan apabila memanggil fungsi untuk dielakkan kekaburan.

Pengkhususan Templat dengan Berbilang Parameter

Untuk terlebih muatan berdasarkan parameter berbeza untuk jenis nilai pulangan yang sama, cipta templat berasingan untuk setiap kombinasi parameter:

template<typename T>
T mul(int, int)
{
    // Generic function with a dummy member variable that will cause a compilation error
    // if not specialized
    const int k = 25;
    k = 36;
}

template<>
int mul<int>(int, int)
{
    return i * j;
}

template<typename T>
T mul(char, int)
{
    // Generic function with a dummy member variable that will cause a compilation error
    // if not specialized
    const int k = 25;
    k = 36;
}

template<>
std::string mul<std::string>(char, int)
{
    return std::string(j, static_cast<char>(i));
}

int n = mul<int>(6, 3); // n = 18
std::string s = mul<std::string>('6', 3); // s = "666"

Menggunakan teknik ini, anda boleh membebankan fungsi secara berkesan berdasarkan nilai pulangannya, membolehkan lebih serba boleh dan kod fleksibel.

Atas ialah kandungan terperinci Bolehkah Fungsi C Dibebankan Berdasarkan Nilai Pulangannya?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!