The UNIX and Linux Forums  
Hello and Welcome from United States to the UNIX and Linux Forums! Thank You for Visiting and Joining Our Global Community.

Go Back   The UNIX and Linux Forums > Top Forums > High Level Programming
.
google unix.com



High Level Programming Post questions about C, C++, Java, SQL, and other programming languages here.

More UNIX and Linux Forum Topics You Might Find Helpful
Thread Thread Starter Forum Replies Last Post
ksh template (scriptt.sh) iBot Solaris BigAdmin RSS 0 03-13-2009 08:20 AM
Template problem ... amartya_sock High Level Programming 1 09-24-2008 05:52 AM
create users from template rijeshpp Shell Programming and Scripting 0 10-31-2007 10:29 AM
vi calling template Euler04 UNIX for Dummies Questions & Answers 1 11-22-2005 10:06 AM
About template constraints sarwan High Level Programming 0 11-21-2005 04:11 AM

 
English Japanese Spanish French German Portuguese Italian Dutch Swedish Russian Norwegian Hungarian Hebrew Danish Bulgarian Greek Powered by Powered by Google
 
LinkBack Thread Tools Search this Thread Rate Thread Display Modes
Prev Previous Post   Next Post Next
  #1 (permalink)  
Old 08-07-2009
MartinM09 MartinM09 is offline
Registered User
  
 

Join Date: Aug 2009
Location: Bavarian, Germany
Posts: 6
Problems with template instantiation in C++

I use the the g++ 4.3.2 compiler on my linux machine. If I compile the following piece of code I get a bunch of compiler time error. In my opinion the compiler
have all information to process the code properly. I can't imagine, what's
going wrong?

Sorry for the long code portion, but I have reduced the code as much as possible! You can view the source code and additionally the compiler error message!

Code:
#ifndef   __EDIFACT_FACETTE__H__                                                
#  define __EDIFACT_FACETTE__H__                                                

#include <iosfwd>
#include <ios>   
#include <locale>
#include <iostream>
#include <streambuf>
#include <locale>   
#include <string>   




namespace Edifact {
        using namespace std;

class         EdifactFormat;
class         ElementFormat;

template <class Ch, class Tr, class In> class   EdifactSibling;
template <class Ch, class Tr, class In> class   ElementSibling;

template <class Ch, class Tr, class In> class                Request;
template <class Ch, class Tr, class In> class         ServiceRequest;

template <class Ch, class Tr> class ServiceCharacters;
template <class Ch, class Tr> class Definition;       
template <class Ch, class Tr> class UNOCharTraits;    
template <class Ch, class Tr> class EdifactSet;       
template <class Ch, class Tr> class Standard;         

template <class Ch, class Tr, class In> class Carrier;
template <class Ch, class Tr, class In> class Line;   
template <class Ch, class Tr, class In> class Channel;

template <class Ch, class Tr, class In> class Syntax;

template <class Ch, class Tr> class Discriminante;
template <class Ch, class Tr> class EdifactEvent; 
template <class Ch, class Tr> class ServiceEvent; 

template <class Ch, class Tr, class In>
        const EdifactSibling<Ch, Tr, In> *edifact_sibling(
                                        basic_istream<Ch, Tr> &is);

template <class Ch, class Tr = char_traits<Ch>,
                                        class In = istreambuf_iterator<Ch, Tr> >
class Edifact_get: public std::locale::facet {                                  
public:                                                                         
        typedef Ch   char_type;                                                 
        typedef Tr traits_type;                                                 
        typedef In   iter_type;                                                 
        typedef         ElementFormat un_element;                               
        typedef         EdifactFormat un_edifact;                               

        typedef Edifact_get<Ch, Tr, In> facet_type;

        typedef ServiceCharacters<Ch, Tr> service;
        typedef EdifactSet<Ch, Tr> un_set;        

        typedef EdifactSibling<Ch, Tr, In> sibling_type;

        typedef    Discriminante<Ch, Tr    > discriminante_type;
        typedef     EdifactEvent<Ch, Tr    >         event_type;
        typedef     ServiceEvent<Ch, Tr    > service_event_type;

        typedef             Line<Ch, Tr, In>          line_type;
        typedef          Carrier<Ch, Tr, In>       carrier_type;

        typedef                Request<Ch, Tr, In>                  request_type;                                                                               
        typedef         ServiceRequest<Ch, Tr, In>          service_request_type;                                                                               

        typedef request_type *(Edifact_get::*Postfix)();

        typedef std::basic_string <Ch, Tr>  string_type;
        typedef std::basic_ios    <Ch, Tr>     ios_type;
        typedef std::basic_istream<Ch, Tr> istream_type;

protected:

        Edifact_get();

        virtual ~Edifact_get();

public:
        In get(In begin, In end, ios_type &s, ios_base::iostate &r,
                                        string_type &element);     

        In begin_of_element(In begin, In end, ios_type &s,
                                        ios_base::iostate &r, un_element &locale, bool mandatory);                                                              

        In trigger(In begin, In end, ios_type &s, ios_base::iostate &error);

        In end_of_element(In begin, In end, ios_type &s, ios_base::iostate &r);

        void set_character_set(ios_type &s, ios_base::iostate &r,
                                        string_type &uno);       

        void set_service_characters(ios_type &s, ios_base::iostate &r,
                                        string_type &una);            

        const string &_0052(ios_type &s) const;

        void init(event_type *edifact, ios_type &s);
        void destroy(ios_type &s);                  

protected:  friend const sibling_type *Edifact::edifact_sibling
                        <Ch, Tr, In>(basic_istream<Ch, Tr> &s);

        sibling_type *edifact_sibling(ios_type &s);

        sibling_type *edifact_sibling(istream_type &is);

        const sibling_type *edifact_sibling(ios_type &s) const;

        const sibling_type *edifact_sibling(istream_type &is) const;

        int status() const;

public:
        discriminante_type *discriminante(ios_type &s) const;

        void set_discriminante(ios_type &s, discriminante_type *value);

        int discriminante() const;

};

template <class Ch, class Tr = char_traits<Ch>,
                 class In = istreambuf_iterator<Ch, Tr> >
class edifact_get: public Edifact_get<Ch, Tr, In> {      
public:                                                  
        static typename locale::id id;                   
};                                                       

} // namespace Edifact

#endif

namespace Edifact {
        using namespace std;

template <class Ch, class Tr = char_traits<char>,
                 class In = istreambuf_iterator<char, char_traits<char> > >
class Typedefines {                                                        
        public:                                                            
                typedef const string &(                                    
                        Edifact_get<Ch, Tr, In>::*Discriminante)(          
                                basic_ios<Ch, Tr> &s) const;               
                typedef In (Edifact_get<Ch, Tr, In>::*SetGetElementFormat)(
                                In begin, In end, basic_ios<Ch, Tr> &s, ios_base::iostate &r,                                                                   
                                ElementFormat   &token, bool mandatory);        
                typedef In (Edifact_get<Ch, Tr, In>::*Terminator)(              
                                In begin, In end, basic_ios<Ch, Tr> &s, ios_base::iostate &r);                                                                  
                typedef void (Edifact_get<Ch, Tr, In>::*Inspector)(             
                                basic_ios<Ch, Tr> &s, ios_base::iostate &r,     
                                basic_string<Ch, Tr> &monitor);                 
};                                                                              

template class Typedefines<char>;

export template <class Ch, class Tr, class In>
const EdifactSibling<Ch, Tr, In> *edifact_sibling(
                                basic_istream<Ch, Tr> &is) {
        const EdifactSibling<Ch, Tr, In> *status;           

        status = use_facet<Edifact::edifact_get<Ch, Tr, In> >(
                                        is.getloc()).edifact_sibling(is);
        return status;                                                   
}                                                                        

template const EdifactSibling<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > > *edifact_sibling                                                                               
                 <char, char_traits<char>,                                      
                 istreambuf_iterator<char, char_traits<char> > >(istream &is);  

export template <class Ch, class Tr, class In>
const string &discriminante(basic_istream<Ch, Tr> &is,
                                typename Typedefines<Ch, Tr, In>::Discriminante disc) {                                                                         
        static string empty;                                                    
        const string &result = empty;                                           

                result = (use_facet<edifact_get<Ch, Tr, In> >(is.getloc()).*disc)(is);                                                                          
        return result;                                                          
}                                                                               

template const string &discriminante<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is,
                                Typedefines<char>::Discriminante disc);      

export template <class Ch, class Tr, class In>
const string &_0052(basic_istream<Ch, Tr> &is) {
        return discriminante(is, &Edifact_get<Ch, Tr, In>::_0052);
}                                                                 

template const string &_0052<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is);

export template <class Ch, class Tr, class In>
bool skipped(basic_istream<Ch, Tr> &is) {     
        return skipped(edifact_sibling(is));  
}                                             

template bool skipped<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is);

export template <class Ch, class Tr, class In>
bool omit(basic_istream<Ch, Tr> &is) {        
        return omit(edifact_sibling(is));     
}                                             

template bool omit<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is);

export template <class Ch, class Tr, class In>
bool exist(basic_istream<Ch, Tr> &is) { return !omit(is); }

template bool exist<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is);

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &operator>>(basic_istream<Ch, Tr> &is,
                                basic_string<Ch, Tr> &s) {  
        ios_base::iostate state = ios_base::goodbit;  // good
        In eos;                                              
                use_facet<edifact_get<Ch, Tr, In> >(         
                                                is.getloc()).get(is, eos, is, state, s);                                                                        
        return is;                                                              
}                                                                               

template istream &operator>><char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is, string &s);                                                                       

export template <class Ch, class Tr, class In, class Ef, typename SgF>
basic_istream<Ch, Tr> &dataScanStatus(                                
                                basic_istream<Ch, Tr> &is,            
                                Ef &un_format, bool mandatory, SgF status) {
        ios_base::iostate state = ios_base::goodbit;  // good               
        In eos;                                                             

                (use_facet<edifact_get<Ch, Tr, In> >(is.getloc()).*status)
                                (is, eos, is, state, un_format, mandatory);
        return is;                                                         
}                                                                          

template istream &dataScanStatus<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> >, ElementFormat,
                Typedefines<char>::SetGetElementFormat>(                      
                                                istream &is, ElementFormat &un_format,                                                                          
                                bool mandatory, Typedefines<char>::SetGetElementFormat sgef);                                                                   

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &control(basic_istream<Ch, Tr> &is,
                                typename Typedefines<Ch, Tr, In>::Terminator terminator) {                                                                      
        In eos;                                                                 
        ios_base::iostate r = ios_base::goodbit;                                

                (use_facet<edifact_get<Ch, Tr, In> >(
                                                                is.getloc()).*terminator)(is, eos, is, r);                                                      
        return is;                                                              
}                                                                               

template istream &control<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is,
                                Typedefines<char>::Terminator terminator);   

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &monitoring(basic_istream<Ch, Tr> &is,
                                basic_string<Ch, Tr> &monitor,
                                typename Typedefines<Ch, Tr, In>::Inspector inspector) {                                                                        
        ios_base::iostate r = ios_base::goodbit;                                

                (use_facet<edifact_get<Ch, Tr, In> >(
                                                                        is.getloc()).*inspector)(is, r, monitor);                                               
        return is;                                                              
}                                                                               

template istream &monitoring<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(
                                                 istream &is, string &monitor,
                                Typedefines<char>::Inspector inspector);      

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &begin_of_element(      
                                basic_istream<Ch, Tr> &is, ElementFormat &un_element,                                                                           
                                bool mandatory) {                               
        return dataScanStatus(is, un_element, mandatory,                        
                                        &Edifact_get<Ch, Tr, In>::begin_of_element);                                                                            
}                                                                               

template istream &begin_of_element<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(
                                                 istream &is, ElementFormat &un_element,                                                                        
                                bool mandatory);                                

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &end_of_element(basic_istream<Ch, Tr> &is) {
        return control(is, &Edifact_get<Ch, Tr, In>::end_of_element);
}                                                                    

template istream &end_of_element<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is);

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &trigger(basic_istream<Ch, Tr> &is) {
        return control(is, &Edifact_get<Ch, Tr, In>::trigger);
}

template istream &trigger<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(istream &is);

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &set_service_characters(
                                basic_istream<Ch, Tr> &is, basic_string<Ch, Tr>&monitor) {
        return monitoring(is, monitor,
                                        &Edifact_get<Ch, Tr, In>::set_service_characters);
}

template istream &set_service_characters<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(
                                                 istream &is, string &monitor);

export template <class Ch, class Tr, class In>
basic_istream<Ch, Tr> &set_character_set(basic_istream<Ch, Tr> &is,
                                basic_string<Ch, Tr> &monitor) {
        return monitoring(is, monitor, &Edifact_get<Ch, Tr, In>::set_character_set);
}

template istream &set_character_set<char, char_traits<char>,
                 istreambuf_iterator<char, char_traits<char> > >(
                                                 istream &is, string &monitor);

} // namespace Edifact
Quote:
xing.cc:163: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:178: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:192: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:200: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:208: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:216: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:222: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:235: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:253: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:268: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:284: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:297: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:305: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:313: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc:324: warning: keyword ‘export’ not implemented, and will be ignored
xing.cc: In function ‘const std::string& Edifact::discriminante(std::basic_istream<_CharT, _Traits>&, typename Edifact::Typedefines<Ch, Tr, In>::Discriminante) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:190: instantiated from here
xing.cc:184: error: passing ‘const std::string’ as ‘this’ argument of ‘std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]’ discards qualifiers
xing.cc: In function ‘const std::string& Edifact::_0052(std::basic_istream<_CharT, _Traits>&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:198: instantiated from here
xing.cc:194: error: no matching function for call to ‘discriminante(std::basic_istream<char, std::char_traits<char> >&, const std::string& (Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >::*)(std::basic_ios<char, std::char_traits<char> >&)const)’
xing.cc: In function ‘bool Edifact::skipped(std::basic_istream<_CharT, _Traits>&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:206: instantiated from here
xing.cc:202: error: no matching function for call to ‘edifact_sibling(std::basic_istream<char, std::char_traits<char> >&)’
xing.cc: In function ‘bool Edifact::omit(std::basic_istream<_CharT, _Traits>&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:214: instantiated from here
xing.cc:210: error: no matching function for call to ‘edifact_sibling(std::basic_istream<char, std::char_traits<char> >&)’
xing.cc: In function ‘bool Edifact::exist(std::basic_istream<_CharT, _Traits>&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:220: instantiated from here
xing.cc:217: error: no matching function for call to ‘omit(std::basic_istream<char, std::char_traits<char> >&)’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::operator>>(std::basic_istream<_CharT, _Traits>&, std::basic_string<Ch, Tr, std::allocator<_CharT> >&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:233: instantiated from here
xing.cc:227: error: passing ‘const Edifact::edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >’ as ‘this’ argument of ‘In Edifact::Edifact_get<Ch, Tr, In>::get(In, In, std::basic_ios<_CharT, _Traits>&, std::_Ios_Iostate&, std::basic_string<Ch, Tr, std::allocator<_CharT> >&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’ discards qualifiers
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::dataScanStatus(std::basic_istream<_CharT, _Traits>&, Ef&, bool, SgF) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >, Ef = Edifact::ElementFormat, SgF = std::istreambuf_iterator<char, std::char_traits<char> > (Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >::*)(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::basic_ios<char, std::char_traits<char> >&, std::_Ios_Iostate&, Edifact::ElementFormat&, bool)]’:
xing.cc:251: instantiated from here
xing.cc:242: error: invalid conversion from ‘const Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >*’ to ‘Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >*’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::control(std::basic_istream<_CharT, _Traits>&, typename Edifact::Typedefines<Ch, Tr, In>::Terminator) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:266: instantiated from here
xing.cc:259: error: invalid conversion from ‘const Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >*’ to ‘Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >*’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::monitoring(std::basic_istream<_CharT, _Traits>&, std::basic_string<Ch, Tr, std::allocator<_CharT> >&, typename Edifact::Typedefines<Ch, Tr, In>::Inspector) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:282: instantiated from here
xing.cc:274: error: invalid conversion from ‘const Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >*’ to ‘Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >*’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::begin_of_element(std::basic_istream<_CharT, _Traits>&, Edifact::ElementFormat&, bool) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:295: instantiated from here
xing.cc:289: error: no matching function for call to ‘dataScanStatus(std::basic_istream<char, std::char_traits<char> >&, Edifact::ElementFormat&, bool&, std::istreambuf_iterator<char, std::char_traits<char> > (Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >::*)(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::basic_ios<char, std::char_traits<char> >&, std::_Ios_Iostate&, Edifact::ElementFormat&, bool))’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::end_of_element(std::basic_istream<_CharT, _Traits>&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:303: instantiated from here
xing.cc:299: error: no matching function for call to ‘control(std::basic_istream<char, std::char_traits<char> >&, std::istreambuf_iterator<char, std::char_traits<char> > (Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >::*)(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::basic_ios<char, std::char_traits<char> >&, std::_Ios_Iostate&))’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::trigger(std::basic_istream<_CharT, _Traits>&) [with Ch = char, Tr = std::char_traits<char>,In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:311: instantiated from here
xing.cc:307: error: no matching function for call to ‘control(std::basic_istream<char, std::char_traits<char> >&, std::istreambuf_iterator<char, std::char_traits<char> > (Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >::*)(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> >, std::basic_ios<char, std::char_traits<char> >&, std::_Ios_Iostate&))’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::set_service_characters(std::basic_istream<_CharT, _Traits>&, std::basic_string<Ch, Tr, std::allocator<_CharT> >&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:322: instantiated from here
xing.cc:317: error: no matching function for call to ‘monitoring(std::basic_istream<char, std::char_traits<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, void (Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >::*)(std::basic_ios<char, std::char_traits<char> >&, std::_Ios_Iostate&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&))’
xing.cc: In function ‘std::basic_istream<_CharT, _Traits>& Edifact::set_character_set(std::basic_istream<_CharT, _Traits>&, std::basic_string<Ch, Tr, std::allocator<_CharT> >&) [with Ch = char, Tr = std::char_traits<char>, In = std::istreambuf_iterator<char, std::char_traits<char> >]’:
xing.cc:332: instantiated from here
xing.cc:327: error: no matching function for call to ‘monitoring(std::basic_istream<char, std::char_traits<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, void (Edifact::Edifact_get<char, std::char_traits<char>, std::istreambuf_iterator<char, std::char_traits<char> > >::*)(std::basic_ios<char, std::char_traits<char> >&, std::_Ios_Iostate&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&))’
 

Bookmarks

Tags
c++, facets, instantiation, template

Thread Tools Search this Thread
Search this Thread:

Advanced Search
Display Modes Rate This Thread
Rate This Thread:

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are On




All times are GMT -4. The time now is 10:59 AM.


Powered by: vBulletin, Copyright ©2000 - 2006, Jelsoft Enterprises Limited. Language Translations Powered by .
vBCredits v1.4 Copyright ©2007 - 2008, PixelFX Studios
The UNIX and Linux Forums Content Copyright ©1993-2009. All Rights Reserved.Ad Management by RedTyger

Content Relevant URLs by vBSEO 3.2.0