C++超載靜態常量字符串VS字符數組

Question

我想獲得三個不同的功能，像這樣的呼叫：

foo("aa"); 

像這樣的人，因爲這樣的電話

char buf[2]; 
foo(buf); 

和一個多種變異之一：

const char *ptr; 
//set ptr 
foo(ptr);//don't know buffer size at compile time 

我試試這個：

//and foo1 for pointers, but how??? 

template<size_t N> 
void foo1(char (&)[N], std::false_type) 
{ 
    std::printf("not const\n"); 
} 

template<size_t N> 
void foo1(const char (&)[N], std::true_type) 
{ 
    std::printf("const\n"); 
} 

template<typename arr_t> 
void foo(arr_t arr) 
{ 
    foo1(std::forward<arr_t>(arr), std::is_const<typename std::remove_reference<arr_t>::type>{}); 
} 

foo("a"); 

但它無法編譯，看起來像「一」轉換爲 const char *不const char (&)[2]，

，但有趣的是，這樣的代碼編譯好：

template<size_t N> 
void f(const char (&)[N]) 
{ 
} 

f("aaaa"); 

所以我怎麼能常數之間重載函數在編譯時（在編譯時知道這個常量的大小）和已知大小的數組，但不是const？

Answer 1

的問題是，此功能由值取它的參數：

template<typename arr_t> 
void foo(arr_t arr) 

無法通過值陣列，它們衰變到指針，所以，當你具有已知長度以與陣列稱之爲它實例foo<const char*>(const char*)或foo<char*>(char*)（取決於數組的常量）並且丟失長度。

你只是想：

template<size_t N> 
void foo(const char (&)[N]) 
{ 
    std::printf("const array\n"); 
} 

template<size_t N> 
void foo(char (&)[N]) 
{ 
    std::printf("non-const array\n"); 
} 

void foo(const char*) 
{ 
    std::printf("not an array\n"); 
} 

Answer 2

這裏有兩個問題。首先，你的調度功能正在通過價值來論證它的論點。要做到完美的轉發，你應該通過轉發引用來引用你的論點。

第二個問題令我感到驚訝的是pointer decay takes priority over a deduced template，所以一個採用指針的函數將優先於一個採用數組的模板來調用。

您可以使用std::is_array類型特徵標記調度。

template<size_t N> 
void foo1(char (&)[N], std::true_type) 
{ 
    std::cout << "array\n"; 
} 

template<size_t N> 
void foo1(const char (&)[N], std::true_type) 
{ 
    std::printf("const array\n"); 
} 

void foo1(const char*, std::false_type) 
{ 
    std::cout << "pointer\n"; 
} 

template<typename T> 
void foo(T&& x) 
{ 
    foo1(std::forward<T>(x), std::is_array< typename std::remove_reference<T>::type >()); 
} 

Live demo.

Answer 3

所以我怎麼可以重載在編譯時間常數之間的函數（知道這個常量在編譯時的大小）和數組與已知的大小，而不是const的？

隨着一個變化，你的代碼是完全正確的，並且正是你想要的。問題是，你沒有做正確完美轉發：

template<typename arr_t> 
void foo(arr_t arr) 
{ 
    foo1(std::forward<arr_t>(arr), std::is_const<typename std::remove_reference<arr_t>::type>{}); 

完美轉發需要使用轉發參考的：

template<typename arr_t> 
void foo(arr_t &&arr) 
{ 
    foo1(std::forward<arr_t>(arr), std::is_const<typename std::remove_reference<arr_t>::type>{}); 

現在，當你傳遞一個字符串字面arr_t將演繹到const char (&)[N]，並且適當的foo1函數將被調用。

當然const也被推斷，並且不需要第二個參數foo1()。

和一個多種變異像這樣一個電話：

該附加匹配char const *過載，但其中規定的隱式轉換，使其比char const (&)較差的匹配。

Live

---

但是如果你只是想這三種類型之間的超載，你不需要亂用完美轉發位都：

template<size_t N> 
void foo(char (&)[N]) 
{ 
    std::printf("not const[]\n"); 
} 

template<size_t N> 
void foo(const char (&)[N]) 
{ 
    std::printf("const[]\n"); 
} 

template<typename T> 
struct dumb_ptr { T *p; dumb_ptr(T *p_) : p(p_) {} }; 

void foo(dumb_ptr<char const>) { 
    std::printf("ptr\n");  
} 

int main() { 

foo("a");   // prints const [] 

char aa[] = "aa"; 
foo(aa);   // prints non const [] 

char const *aaa; 
foo(aaa);   // prints ptr 

char *aaaa; 
foo(aaaa);   // prints ptr 

}