0

我有一个类模板，它又包含一个模板类。该内部模板类又具有作为构造函数的构造函数，该构造函数采用函数指针。我之前使用过这个内部类来加载 XML 文件，现在我正在尝试使用这个类创建一个 XML 转换器。问题在于为内部类提供了一组足够的构造函数参数。

编辑我已经接受了一些关于临时 const 字符串等的评论，并花时间创建一个仍然存在我的问题的简化案例。我对这个问题进行了大量修改。使用下面发布的代码，现在返回的错误是

FormatConverter/main.cpp:7:   instantiated from here
FormatConverter/FormatConverter.h:52: error: no matching function for call to 'XMLLoader<MessageType1>::XMLLoader(<unknown type>, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)'
FormatConverter/XMLLoader.h:40: note: candidates are: XMLLoader<XMLTYPE>::XMLLoader(std::auto_ptr<XMLTYPE> (*)(std::istream&, std::string&, std::string&), const std::string&, const std::string&) [with XMLTYPE = MessageType1]
FormatConverter/XMLLoader.h:10: note: XMLLoader<MessageType1>::XMLLoader(const XMLLoader<MessageType1>&)

//main.cpp

#include <iostream>
#include "FormatConverter.h"
#include "MessageTypes.h"

int main (int argc, char * const argv[]) {
std::string options = "";
FormatConverter<MessageType1, MessageType2> fConverter( options );
    return 0;
}

//MessageTypes.h

#ifndef _MTYPES_
#define _MTYPES_

class MessageType1 
{  };

class MessageType2
{  };

#endif

//格式转换器.h

#ifndef _FORMAT_CONVERTER_
#define _FORMAT_CONVERTER_

#include "XMLLoader.h"
#include <memory>
#include <string>

template<typename T>
::std::auto_ptr<T>
dummyLoader( ::std::istream& dummyStream, std::string dummyFlags, std::string dummyProps )
{
return ::std::auto_ptr<T>( new(T) );
}

template<>
::std::auto_ptr<MessageType1>
dummyLoader( ::std::istream& dummyStream, std::string dummyFlags, std::string dummyProps )
{
return ::std::auto_ptr<MessageType1>( new(MessageType1) );
}

template<>
::std::auto_ptr<MessageType2>
dummyLoader( ::std::istream& dummyStream, std::string dummyFlags, std::string dummyProps )
{
return ::std::auto_ptr<MessageType2>( new(MessageType2) );
}

template <typename IN, typename OUT>
class FormatConverter {
public:
FormatConverter( std::string& options );
virtual ~FormatConverter( void );

void convert( std::auto_ptr<IN> input, std::string& stuff );

private:    
std::string options_;
const std::string dummyFlags;
const std::string dummyProps;

XMLLoader<IN> loader_;
};

template <typename IN, typename OUT>
FormatConverter<IN, OUT>::FormatConverter( std::string& options )
: options_(options)
, dummyFlags("")
, dummyProps("")
, loader_ ( dummyLoader<IN>,
        dummyFlags,
        dummyProps )
{ }

template <typename IN, typename OUT>
FormatConverter<IN,OUT>::~FormatConverter( void )
{ }

template<typename IN, typename OUT>
void
FormatConverter<IN, OUT>::convert( std::auto_ptr<IN> input, std::string& stuff )
{ }
#endif

//XMLLoader.h

#ifndef _XMLLoader_H
#define _XMLLoader_H

#include <memory>
#include <string>

template <typename XMLTYPE>
class XMLLoader
    {
    public:
        typedef ::std::auto_ptr<XMLTYPE> MSG_LOADER( std::istream&,
                                                 std::string&,   //flags
                                                         std::string& ); //properties

        XMLLoader(  MSG_LOADER *loader,
                        const std::string& schemaSource = "NONE",
                        const std::string& ns="" );

        virtual ~XMLLoader(void);
        virtual std::auto_ptr<XMLTYPE> load(std::istream &is);

    private:
        MSG_LOADER* loader_;
        std::string schemaSource_;
        std::string namespace_;
    };

#include <unistd.h>
#include <stdexcept>
#include "XMLLoader.h"

template<typename XMLTYPE>
XMLLoader<XMLTYPE>::XMLLoader(MSG_LOADER* loader,
                              const std::string& schemaSource,
                              const std::string& ns)
: loader_(loader)
, schemaSource_(schemaSource)
, namespace_(ns)
{ /* stuff */ }

template<typename XMLTYPE>
XMLLoader<XMLTYPE>::~XMLLoader( void )
{ }

template<typename XMLTYPE>
::std::auto_ptr<XMLTYPE>
XMLLoader<XMLTYPE>::load( std::istream& is )
{
    std::string flags = "";
    std::string props = "";
    return loader_(is, flags, props );
}

#include "MessageTypes.h"

template
XMLLoader<MessageType1>::XMLLoader(
                                   MSG_LOADER*,
                                   const std::string&,
                                   const std::string& );

template
XMLLoader<MessageType1>::~XMLLoader( void );

template
XMLLoader<MessageType2>::XMLLoader(
                                   MSG_LOADER*,
                                   const std::string&,
                                   const std::string& );

template
XMLLoader<MessageType2>::~XMLLoader( void );
#endif

XMLLoader<IN> 构造函数接受 3 个参数：两个字符串和一个函数指针。它返回一个 auto_ptr<IN> 类型。我的 dummyLoader 模板似乎满足了这个要求，我尝试了一些对我的语法的细微变化，但错误是指 .

因此，编译器似乎无法识别我在实例化 FormatConverter 对象时尝试传递的 dummyLoader 类型。谁能解释为什么？

4

3 回答 3

1

const从字符串中删除：

loader_(dummyLoader, std::string("namespace"), std::string("schema_loc"))

事实上，std::string有一个完全可用的转换构造函数：

loader_(dummyLoader, "namespace", "schema_loc")

像这样创建的临时值非常乐意绑定到常量引用。

于 2013-09-19T22:03:31.797 回答
0

如果 XMLLoader 的构造函数需要一个函数指针，而 dummyloader 是您的类的一个方法，则它需要绑定到一个对象（例如 this）。

就像是： 

std::bind(&FormatConverter<IN, OUT>::dummyLoader, this)

需要在您试图通过 dummyloader 的地方传递。

于 2013-09-20T16:55:32.747 回答
0

由于代码不完整，我无法编译它，即可能有更多错误。但是，后面缺少一个分号：

FormatConverter( string& options )
于 2013-09-19T22:03:34.223 回答