模板、函数重载及其出现顺序

Templates, function overloading and their order of appearence

本文关键字：顺序 函数 重载 模板      更新时间：2023-10-16

我试图为这个问题做一个简化版本的代码。在这个过程中，我遇到了一些对我来说没有意义的事情。有人能解释一下为什么我得到以下结果吗?下面是代码，它应该在gcc中编译和运行。

#include <string>
#include <iostream>
#include <typeinfo>
using std::string;
template <typename T> inline char getType(const T&) {return 'S'; }
inline char getType(const char&) {return 'C';}
template <typename T> inline char getType(T*) {return 'A'; }
template <typename T> inline void writeData(const T& x) { 
    printf("Calling default writeData...n");
    char type = getType(x);
    if (type == 'S') {
        printf("ERROR: binaryWrite::writeData ->  Structure not defined.n");
        exit(1);
    }
    std::cout << x << std::endl;
}
template <typename T> inline void writeData(T* x, const unsigned int& len) { 
    printf("Writing array with writeData...n");
    char type = getType(x[0]);
    std::cout << len << std::endl;
    if (type == 'S') {
        for (int i=0; i < len; ++i) {
            writeData(x[i]);
        }
    } else {
        for (int i=0; i < len; ++i) {
            std::cout << x[i] << std::endl;
        }
    }   
}
class binaryWrite {
public:
    binaryWrite(void) {}
    template <typename T> 
    void write(const T& x, const char* name) { 
        writeData(x);
    }
};
inline void writeData(const string& s) {
    unsigned int len = s.size();
    const char* pt = s.c_str();
    writeData(pt, len);
}
int main () {
    string str = "Hello World";
    writeData(str);
    binaryWrite BF;
    BF.write(str, "str");
    return 0;
}

输出:

manuel-lopezs-macbook-pro:binaryFiles jmlopez$ g++ -o example example.cpp
manuel-lopezs-macbook-pro:binaryFiles jmlopez$ ./example
Writing array with writeData...
11
H
e
l
l
o
W
o
r
l
d
Calling default writeData...
ERROR: binaryWrite::writeData ->  Structure not defined.

首先用字符串版本调用writeData。在我尝试调用binaryWrite函数write(此函数调用writeData)后，它调用模板定义的函数。

我摆弄了一下，发现如果我把字符串的重载函数移到binaryWrite的类定义上方，那么我就得到了我想要的结果。

这是改变:

inline void writeData(const string& s) {
    unsigned int len = s.size();
    const char* pt = s.c_str();
    writeData(pt, len);
}
class binaryWrite {
public:
    binaryWrite(void) {}
    template <typename T> 
    void write(const T& x, const char* name) { 
        writeData(x);
    }
};

输出

Writing array with writeData...
11
H
e
l
l
o
W
o
r
l
d
Writing array with writeData...
11
H
e
l
l
o
W
o
r
l
d

在第一种情况下，binaryWrite似乎不知道string的重载函数writeData。但是在转换之后，因为我先定义了重载函数，所以它知道。这个解释正确吗?

我最终想做的是将宏WRITESTRUCT用于其他类型，但此定义将在其他一些文件中，因此我将无法在binaryWrite的定义之前编写它们。如果我的解释是正确的，有什么办法可以解决这个问题吗?

好吧，玩你的代码，我发现它也执行正确，如果你移动所有的writeData模板和重载binaryWrite类定义以下。

当编译器遇到binaryWrite::write时，它检查是否有writeData的定义。此时它选择template <typename T> inline void writeData(const T& x)，因为它只能访问前两个模板。然后，它再也不会回去看看是否有更好的选择。

当您将writeData模板移动到binaryWrite之后时，编译器没有writeData的定义，并决定在模板实例化期间再次查找。所以当你使用binaryWrite::write时，它会选择直接重载，而不是模板。

您的三个函数是:

template <typename T> inline void writeData(const T& x);
template <typename T> inline void writeData(T* x, CIX len);
inline void writeData(const string& s);

我不知道为什么template<typename T> void write(const T& x, const char* name)决定第三个选项不够好，但是如果你把第三个选项变成writeData的模板专门化，而不是重载，问题就会消失:

template <> inline void writeData<string>(const string& s);

同时，去掉那些宏。我看不出WRITESTRUCT(string, s)如何比void writeData(const std::string& s)更清晰，特别是因为没有涉及结构体。

是的，正确的解决方案是移动重载的函数，或者至少是它的声明，这样它对binaryWrite是可见的。

一些编译器不能正确地做这件事，并且在考虑的重载集合中包含在binaryWrite之后但在其使用之前声明的函数。如果不同位置的可见函数集不相同，这会导致有趣的ODR冲突。

相关文章：