Quá tải hàm cho tham chiếu giá trị ký tự và giá trị chuỗi ký tự

1. Trình biên dịch nào là chính xác?

GCC là chính xác.

2. Với clang, tại sao str1 và str2 chọn quá tải rvalue trong khi chúng là giá trị?

Clang là sai trên test(str1);, nó nên được mơ hồ. For test(str2);, str2có thể chuyển đổi hoàn toàn thành con trỏ, tức là phân rã mảng thành con trỏ. Giá trị được chuyển đổi char*là một giá trị. Vì lý do tương tự như # 3, các chuỗi chuyển đổi ngầm định có cùng xếp hạng, thì chức năng không phải mẫu được ưu tiên hơn; test(char*&&)đã được chọn.

3. Với gcc, tại sao cuộc gọi với str1 là mơ hồ?

Để test(const char (&)[1])được gọi, cần phải chuyển đổi trình độ từ char[1]sang const char[1]; cho test(char*&&)được gọi, chuyển đổi mảng-to-con trỏ là bắt buộc. Cả hai đều đủ tiêu chuẩn là đối sánh chính xác và có cùng thứ hạng.

4. Có một quy tắc tiêu chuẩn nào cho tình huống này không?

Xem xếp hạng của chuỗi chuyển đổi ngầm định trong giải quyết quá tải và chuyển đổi ngầm định .

5. Làm thế nào để khắc phục hai cuộc gọi cuối cùng?

Nó phụ thuộc vào ý định của bạn.

Chuỗi ký tự không phải là giá trị. ( → )

5. Làm thế nào để khắc phục hai cuộc gọi cuối cùng?

Bạn có thể phân biệt mọi thứ với các chuyên môn mẫu:

#include <iostream>

template<typename C, std::size_t N>
void test(const C (&)[N]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
template<typename C>
void test(const C (&)[1]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
template<typename C, std::size_t N>
void test(const C (&&)[N]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
template<typename C>
void test(const C (&&)[1]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
template<typename C, std::size_t N>
void test(C (&)[N]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
template<typename C>
void test(C (&)[1]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
template<typename C, std::size_t N>
void test(C (&&)[N]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
template<typename C>
void test(C (&&)[1]) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

int main(){
    char str1[] = "";
    char str2[] = "test";
    test("");
    test("test");
    test(str1);
    test(str2);
    test(std::move(str1));
    test(std::move(str2));
    const char str3[] = "";
    const char str4[] = "test";
    test(std::move(str3));
    test(std::move(str4));
}

cho

void kiểm tra (const C (&) [1]) [với C = char]
kiểm tra void (const C (&) [N]) [với C = char; long unsigned int N = 5]
void test (C (&) [1]) [with C = char]
void test (C (&) [N]) [with C = char; long unsigned int N = 5]
void test (C (&&) [1]) [with C = char]
void test (C (&&) [N]) [with C = char; long unsigned int N = 5]
void test (const C (&&) [1]) [with C = char]
void test (const C (&&) [N]) [with C = char; long unsigned int N = 5]

Cảm ơn bạn @songyuanyao vì câu trả lời của bạn, giờ tôi đã hiểu tại sao lại test(char*&&)được chọn trong hai trường hợp cuối cùng. Tôi đã có thể loại bỏ sự mơ hồ với chuyên môn hóa mẫu trong lần quá tải đầu tiên nhờ câu trả lời @Darklighter.

Vì vậy, tôi đã giải quyết vấn đề của mình chẳng hạn như dưới đây:

#include <iostream>

template <unsigned long int N>
void test(const char (&)[N]){
    std::cout << __PRETTY_FUNCTION__ << " //non-empty literal" << std::endl;
}

template <>
void test(const char (&)[1]){
    std::cout << __PRETTY_FUNCTION__ << " //empty literal" << std::endl;
}

void test(char*&&){
    std::cout << __PRETTY_FUNCTION__ << " //string variable" << std::endl;
}

int main(){
    char str1[] = "";
    char str2[] = "test";
    test("");
    test("test");
    test(str1);
    test(str2);
}

Đầu ra:

clang++ test.cpp -o test.out && ./test.out
void test(const char (&)[1]) //empty literal
void test(const char (&)[N]) [N = 5] //non-empty literal
void test(char *&&) //string variable
void test(char *&&) //string variable

g++ test.cpp -o test.exe && test.exe
void test(const char (&)[N]) [with long unsigned int N = 1] //empty literal
void test(const char (&)[N]) [with long unsigned int N = 5] //non-empty literal
void test(char*&&) //string variable
void test(char*&&) //string variable