C++重载函数调用歧义求助：元素与原子数互查代码报错

错误原因 #

从报错信息能直接定位问题：你同时在exercises命名空间和全局作用域里声明了签名完全相同的lookup重载函数，再加上using namespace exercises把命名空间的函数导入全局作用域，导致编译器每次调用lookup时，都能找到两个匹配的候选函数，无法确定该调用哪一个，因此抛出「Call of overloaded function is ambiguous」错误。

另外代码里还有个语法错误：std::stoi(output) = lookup((std::string)input);——std::stoi返回的是临时整数，不能被赋值，这部分逻辑必须调整。

修复步骤 #

1. 移除重复声明：删掉全局作用域的int lookup(std::string name);和std::string lookup(int atomicNumber);声明，保留exercises命名空间内的声明即可。
2. 统一函数作用域：把全局的两个lookup函数定义移到exercises命名空间内部，确保声明和定义的作用域一致。
3. 修正赋值逻辑：当输入是元素符号时，把lookup返回的原子序数转换成std::string再赋值给output，而非给std::stoi的返回值赋值。
4. 修复循环边界：sizeof(t)返回的是数组总字节数，不是元素个数，要用sizeof(t)/sizeof(t[0])获取正确的循环次数，避免越界访问。

修正后的完整代码 #

// use functions from the standard library (like cout)
#include <iostream>
#include <cctype>
#include <string>
#include <iomanip>

// to avoid name-clashes, create a namespace
namespace exercises
{
    // arrays
    std::string t[4] = {"H", "Rh", "Cl", "C"};
    int s[4] = {1, 45, 17, 6};

    // add elements + lookup functionality
    int lookup(std::string name);
    std::string lookup(int atomicNumber);

    //function definition element symbol --> atomic number
    int lookup(std::string input){
        int output = 1; 
        //check if input is valid, ie if exists in array t
        for(unsigned int i=0; i < sizeof(t)/sizeof(t[0]); i++){
            if(input == t[i]){
                output = s[i];
                return output;
            };
        };
        return output;
    }
    
    //function definition atomic number --> element symbol
    std::string lookup(int input){
        //check if input is valid, ie if exists in array s
        for(unsigned int i=0; i < sizeof(s)/sizeof(s[0]); i++){
            if(input == s[i]){
                return t[i];
            };
        };
        return "error";
    }
} /* end of namespace exercises */

// I want to use the functions from our new namespace...
using namespace exercises;

int main(void)
{
    //declare input and output variable as string temporarily 
    std::string input;
    std::string output;

    //lookup something
    std::cout << "Enter element or atomic number to look up:" << std::endl;
    std::cin >> input;

    //if input is atomic number, make it of type integer to match function input type
    if(std::isdigit(input[0])){
        output = lookup(std::stoi(input));
    }
    //else, convert returned int to string
    else{
        int atomicNum = lookup(input);
        output = std::to_string(atomicNum);
    };

    if(std::isdigit(output[0])){
        if(std::stoi(output) == 1){
            std::cout << "Invalid input!" << std::endl;
            return 0;
        };
    } else if(output == "error"){
        std::cout << "Invalid input!" << std::endl;
        return 0;
    }

    //print output
    std::cout << "|**Sample Input**|**Sample Output**|" << std::endl;
    std::cout << "|" << std::setfill('-') << std::setw(16) << "|" << std::setfill('-') << std::setw(16) << "|" << std::endl;
    std::cout << "|" << std::left << std::setw(16) << input << "|" << std::left << std::setw(16) << output << "|" << std::endl;

    return 0;
}

额外优化说明 #

• 把数组移到命名空间内，避免全局变量污染，符合命名空间的设计初衷。
• 简化了函数内的局部变量声明，让代码更简洁。
• 合并了错误判断逻辑，让代码结构更清晰。

内容的提问来源于stack exchange，提问作者Ani0000