调用非模板化类c ++的模板化函数时出错

Question

I have a templated function inside a non-templated class, like so:

class Foo
{
  public:
  template <class T>
  void func(T& val)
  {
     //do work here
  }
}

Then, in main.cpp I'm doing:

Foo a;
std::string val;
a.func<std::string>(val);  //this line gives the error

I get an error saying "primary expression expected before '>'" . So I do a quick Google search and find that everyone suggests a simple solution:

a.template func<std::string>(val);

Only problem is, I'm still getting the exact same error.

EDIT :

The reason I wasn't giving the full example is because it involves external libraries and lengthy code that obscures the question, but since the simplified code above doesn't cut it. Here's the complete class that I wrote:

class ConfigFileReader
{
public:
    ConfigFileReader() { }

    ConfigFileReader(const std::string& config_file_path)
    {
      setConfigFilePath(config_file_path);
    }

    ~ConfigFileReader() { }

    void setConfigFilePath(const std::string& config_file_path)
    {
    try
    {
        root_node_ = YAML::LoadFile(config_file_path);
    }
    catch(const YAML::BadFile& file_load_exception)
    {
        printf("Error opening YAML file. Maybe the file path is incorrect\n%s", file_load_exception.msg.c_str());
    }

    }

    template<class T>
    bool getParam(const std::string& param_key, T& param_value)
    {
        if (root_node_.IsNull() || !root_node_.IsDefined())
        {
            printf("Root node is undefined or not set");
            return false;
        }

        YAML::Node node = YAML::Clone(root_node_);

        std::vector<std::string> split_name;
        boost::split(split_name, param_key, boost::is_any_of("/"));

        for(const std::string& str: split_name)
        {
            if (!node.IsMap())
            {
                std::cout << "Parameter was not found (Node is null)." << str << std::endl;   //replace with printf
                return false;
            }

            node = node[str];
        }

        if (node.IsNull() || !node.IsDefined())
        {
            std::cout << "Parameter was not found (Node is null/undefined)." << std::endl;
            return false;
        }

        try
        {
            param_value = node.as<T>();
            return true;
        }
        catch (const YAML::TypedBadConversion<T>& type_conversion_exception)
        {
            std::cout << "Error converting param value into specified data type" << std::endl;
            std::cout << type_conversion_exception.msg << std::endl;
        }

        return false;
    }

private:
    YAML::Node root_node_;
};

Then, in a separate cpp file is the main function

int main(int argc, char** argv)
{
if (argc != 2)
{
  printf("Incorrect number of arguments given");
    return EXIT_FAILURE;
}

printf("Config file path: %s", argv[1]);

ConfigFileReader config_file_reader(std::string(argv[1]));

std::string param_out;

bool success = config_file_reader.template getParam<std::string>("controller/filepath", param_out);  //<-- ERROR HERE

return EXIT_SUCCESS;
}

Compiler: gcc 4.8.4, and c++11 flag set when compiling.

EDIT 2: Added string argument constructor to the code.

Answer 1

Your problem is that this:

ConfigFileReader config_file_reader(std::string(argv[1]));

Is interpreted as a forward declaration for a function named config_file_reader that accepts a pointer to a string. See the error message:

ConfigFileReader(std::__cxx11::string*) {aka ConfigFileReader(std::__cxx11::basic_string*)}'

This is because you've encountered The most vexing parse

Use ConfigFileReader config_file_reader(std::string{argv[1]}); to better disambiguate for the compiler that you are intending to construct an object. Then the compiler will start complaining that you're missing a constructor that accepts a string!

You do have a default constructor, so when we use that:

ConfigFileReader config_file_reader;

It works without issue.

So:

1. define a constructor for ConfigFileReader that accepts a string , then
2. Call it in such a way that the code is unambiguous

Demo

Answer 2

It's even simpler:

Foo a;
std::string val;
a.func(val);  // The compiler assumes T = std::string