« _FCbuild » ne peut pas être utilisé en fonction - c/C++ erreur de code

ici est mon code C++ de la bibliothèque Boost .. Quand je tente de compiler ce code pour mon QNX avec processeur ARM, ses 2 erreurs lancer -« _FCbuild » ne peut pas être utilisé en fonction - c/C++ erreur de code

'_FCbuild' ne peut pas être utilisé en fonction
attendue '>' avant '(' jeton

à la fois les erreurs sont lancées sur le code suivant

template<class T, std::size_t I, unsigned N> 
struct extent<T[I], N> 
{ 
    static const std::size_t value = extent<T, N-1>::value; 
};

Tout semble bien .. Mais je ne sais pas pourquoi il lance cette erreur .. quelqu'un est tombé sur l'erreur similaire et résolu?

ici est tout le code:

#ifndef BOOST_MOVE_UNIQUE_PTR_DETAIL_META_UTILS_HPP 
#define BOOST_MOVE_UNIQUE_PTR_DETAIL_META_UTILS_HPP 

#ifndef BOOST_CONFIG_HPP 
# include <boost/config.hpp> 
#endif 
# 
#if defined(BOOST_HAS_PRAGMA_ONCE) 
# pragma once 
#endif 

#include <cstddef> //for std::size_t 

//Small meta-typetraits to support move 

namespace boost { 

namespace movelib { 

template <class T> 
struct default_delete; 

} //namespace movelib { 

#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES 
//Forward declare boost::rv 
template <class T> class rv; 
#endif 

namespace move_upmu { 

////////////////////////////////////// 
//    nat 
////////////////////////////////////// 
struct nat{}; 

////////////////////////////////////// 
//   natify 
////////////////////////////////////// 
template <class T> struct natify{}; 

////////////////////////////////////// 
//    if_c 
////////////////////////////////////// 
template<bool C, typename T1, typename T2> 
struct if_c 
{ 
    typedef T1 type; 
}; 

template<typename T1, typename T2> 
struct if_c<false,T1,T2> 
{ 
    typedef T2 type; 
}; 

////////////////////////////////////// 
//    if_ 
////////////////////////////////////// 
template<typename T1, typename T2, typename T3> 
struct if_ : if_c<0 != T1::value, T2, T3> 
{}; 

//enable_if_ 
template <bool B, class T = nat> 
struct enable_if_c 
{ 
    typedef T type; 
}; 

////////////////////////////////////// 
//   enable_if_c 
////////////////////////////////////// 
template <class T> 
struct enable_if_c<false, T> {}; 

////////////////////////////////////// 
//   enable_if 
////////////////////////////////////// 
template <class Cond, class T = nat> 
struct enable_if : public enable_if_c<Cond::value, T> {}; 

////////////////////////////////////// 
//   remove_reference 
////////////////////////////////////// 
template<class T> 
struct remove_reference 
{ 
    typedef T type; 
}; 

template<class T> 
struct remove_reference<T&> 
{ 
    typedef T type; 
}; 

#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 

template<class T> 
struct remove_reference<T&&> 
{ 
    typedef T type; 
}; 

#else 

template<class T> 
struct remove_reference< rv<T> > 
{ 
    typedef T type; 
}; 

template<class T> 
struct remove_reference< rv<T> &> 
{ 
    typedef T type; 
}; 

template<class T> 
struct remove_reference< const rv<T> &> 
{ 
    typedef T type; 
}; 


#endif 

////////////////////////////////////// 
//    remove_const 
////////////////////////////////////// 
template< class T > 
struct remove_const 
{ 
    typedef T type; 
}; 

template< class T > 
struct remove_const<const T> 
{ 
    typedef T type; 
}; 

////////////////////////////////////// 
//    remove_volatile 
////////////////////////////////////// 
template< class T > 
struct remove_volatile 
{ 
    typedef T type; 
}; 

template< class T > 
struct remove_volatile<volatile T> 
{ 
    typedef T type; 
}; 

////////////////////////////////////// 
//    remove_cv 
////////////////////////////////////// 
template< class T > 
struct remove_cv 
{ 
    typedef typename remove_volatile 
     <typename remove_const<T>::type>::type type; 
}; 

////////////////////////////////////// 
//   remove_extent 
////////////////////////////////////// 
template<class T> 
struct remove_extent 
{ 
    typedef T type; 
}; 

template<class T> 
struct remove_extent<T[]> 
{ 
    typedef T type; 
}; 

template<class T, std::size_t N> 
struct remove_extent<T[N]> 
{ 
    typedef T type; 
}; 

////////////////////////////////////// 
//    extent 
////////////////////////////////////// 

template<class T, unsigned N = 0> 
struct extent 
{ 
    static const std::size_t value = 0; 
}; 

template<class T> 
struct extent<T[], 0> 
{ 
    static const std::size_t value = 0; 
}; 


template<class T, std::size_t I, unsigned N> 
struct extent<T[I], N> 
{ 
    static const std::size_t value = extent<T, N-1>::value; 
}; 

template<class T, unsigned N> 
struct extent<T[], N> 
{ 
    static const std::size_t value = extent<T, N-1>::value; 
}; 

template<class T, std::size_t N> 
struct extent<T[N], 0> 
{ 
    static const std::size_t value = N; 
}; 

////////////////////////////////////// 
//  add_lvalue_reference 
////////////////////////////////////// 
template<class T> 
struct add_lvalue_reference 
{ 
    typedef T& type; 
}; 

template<class T> 
struct add_lvalue_reference<T&> 
{ 
    typedef T& type; 
}; 

template<> 
struct add_lvalue_reference<void> 
{ 
    typedef void type; 
}; 

template<> 
struct add_lvalue_reference<const void> 
{ 
    typedef const void type; 
}; 

template<> 
struct add_lvalue_reference<volatile void> 
{ 
    typedef volatile void type; 
}; 

template<> 
struct add_lvalue_reference<const volatile void> 
{ 
    typedef const volatile void type; 
}; 

template<class T> 
struct add_const_lvalue_reference 
{ 
    typedef typename remove_reference<T>::type t_unreferenced; 
    typedef const t_unreferenced     t_unreferenced_const; 
    typedef typename add_lvalue_reference 
     <t_unreferenced_const>::type    type; 
}; 

////////////////////////////////////// 
//    is_same 
////////////////////////////////////// 
template<class T, class U> 
struct is_same 
{ 
    static const bool value = false; 
}; 

template<class T> 
struct is_same<T, T> 
{ 
    static const bool value = true; 
}; 

////////////////////////////////////// 
//    is_pointer 
////////////////////////////////////// 
template< class T > 
struct is_pointer 
{ 
    static const bool value = false; 
}; 

template< class T > 
struct is_pointer<T*> 
{ 
    static const bool value = true; 
}; 

////////////////////////////////////// 
//    is_reference 
////////////////////////////////////// 
template< class T > 
struct is_reference 
{ 
    static const bool value = false; 
}; 

template< class T > 
struct is_reference<T&> 
{ 
    static const bool value = true; 
}; 

#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 

template< class T > 
struct is_reference<T&&> 
{ 
    static const bool value = true; 
}; 

#endif 

////////////////////////////////////// 
//    is_lvalue_reference 
////////////////////////////////////// 
template<class T> 
struct is_lvalue_reference 
{ 
    static const bool value = false; 
}; 

template<class T> 
struct is_lvalue_reference<T&> 
{ 
    static const bool value = true; 
}; 

////////////////////////////////////// 
//   is_array 
////////////////////////////////////// 
template<class T> 
struct is_array 
{ 
    static const bool value = false; 
}; 

template<class T> 
struct is_array<T[]> 
{ 
    static const bool value = true; 
}; 

template<class T, std::size_t N> 
struct is_array<T[N]> 
{ 
    static const bool value = true; 
}; 

////////////////////////////////////// 
//   has_pointer_type 
////////////////////////////////////// 
template <class T> 
struct has_pointer_type 
{ 
    struct two { char c[2]; }; 
    template <class U> static two test(...); 
    template <class U> static char test(typename U::pointer* = 0); 
    static const bool value = sizeof(test<T>(0)) == 1; 
}; 

////////////////////////////////////// 
//    pointer_type 
////////////////////////////////////// 
template <class T, class D, bool = has_pointer_type<D>::value> 
struct pointer_type_imp 
{ 
    typedef typename D::pointer type; 
}; 

template <class T, class D> 
struct pointer_type_imp<T, D, false> 
{ 
    typedef typename remove_extent<T>::type* type; 
}; 

template <class T, class D> 
struct pointer_type 
{ 
    typedef typename pointer_type_imp 
     <typename remove_extent<T>::type, typename remove_reference<D>::type>::type type; 
}; 

////////////////////////////////////// 
//   is_convertible 
////////////////////////////////////// 
#if defined(_MSC_VER) && (_MSC_VER >= 1400) 

//use intrinsic since in MSVC 
//overaligned types can't go through ellipsis 
template <class T, class U> 
struct is_convertible 
{ 
    static const bool value = __is_convertible_to(T, U); 
}; 

#else 

template <class T, class U> 
class is_convertible 
{ 
    typedef typename add_lvalue_reference<T>::type t_reference; 
    typedef char true_t; 
    class false_t { char dummy[2]; }; 
    static false_t dispatch(...); 
    static true_t dispatch(U); 
    static t_reference  trigger(); 
    public: 
    static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t); 
}; 

#endif 

////////////////////////////////////// 
//  is_unary_function 
////////////////////////////////////// 
#if defined(BOOST_MSVC) || defined(__BORLANDC_) 
#define BOOST_MOVE_TT_DECL __cdecl 
#else 
#define BOOST_MOVE_TT_DECL 
#endif 

#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE) 
#define BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS 
#endif 

template <typename T> 
struct is_unary_function_impl 
{ static const bool value = false; }; 

// avoid duplicate definitions of is_unary_function_impl 
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS 

template <typename R> 
struct is_unary_function_impl<R (*)()> 
{ static const bool value = true; }; 

template <typename R> 
struct is_unary_function_impl<R (*)(...)> 
{ static const bool value = true; }; 

#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS 

template <typename R> 
struct is_unary_function_impl<R (__stdcall*)()> 
{ static const bool value = true; }; 

#ifndef _MANAGED 

template <typename R> 
struct is_unary_function_impl<R (__fastcall*)()> 
{ static const bool value = true; }; 

#endif 

template <typename R> 
struct is_unary_function_impl<R (__cdecl*)()> 
{ static const bool value = true; }; 

template <typename R> 
struct is_unary_function_impl<R (__cdecl*)(...)> 
{ static const bool value = true; }; 

#endif 

// avoid duplicate definitions of is_unary_function_impl 
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS 

template <typename R, class T0> 
struct is_unary_function_impl<R (*)(T0)> 
{ static const bool value = true; }; 

template <typename R, class T0> 
struct is_unary_function_impl<R (*)(T0...)> 
{ static const bool value = true; }; 

#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS 

template <typename R, class T0> 
struct is_unary_function_impl<R (__stdcall*)(T0)> 
{ static const bool value = true; }; 

#ifndef _MANAGED 

template <typename R, class T0> 
struct is_unary_function_impl<R (__fastcall*)(T0)> 
{ static const bool value = true; }; 

#endif 

template <typename R, class T0> 
struct is_unary_function_impl<R (__cdecl*)(T0)> 
{ static const bool value = true; }; 

template <typename R, class T0> 
struct is_unary_function_impl<R (__cdecl*)(T0...)> 
{ static const bool value = true; }; 

#endif 

template <typename T> 
struct is_unary_function_impl<T&> 
{ static const bool value = false; }; 

template<typename T> 
struct is_unary_function 
{ static const bool value = is_unary_function_impl<T>::value; }; 

////////////////////////////////////// 
//  has_virtual_destructor 
////////////////////////////////////// 
#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\ 
     || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500)) 
# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) 
#elif defined(BOOST_CLANG) && defined(__has_feature) 
# if __has_feature(has_virtual_destructor) 
#  define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) 
# endif 
#elif defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG) 
# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) 
#elif defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600) 
# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) 
#elif defined(__CODEGEARC__) 
# define BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T) 
#endif 

#ifdef BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR 
    template<class T> 
    struct has_virtual_destructor{ static const bool value = BOOST_MOVEUP_HAS_VIRTUAL_DESTRUCTOR(T); }; 
#else 
    //If no intrinsic is available you trust the programmer knows what is doing 
    template<class T> 
    struct has_virtual_destructor{ static const bool value = true; }; 
#endif 

////////////////////////////////////// 
//  missing_virtual_destructor 
////////////////////////////////////// 

template< class T, class U 
     , bool enable = is_convertible< U*, T*>::value && 
         !is_array<T>::value && 
         !is_same<typename remove_cv<T>::type, void>::value && 
         !is_same<typename remove_cv<U>::type, typename remove_cv<T>::type>::value 
     > 
struct missing_virtual_destructor_default_delete 
{ static const bool value = !has_virtual_destructor<T>::value; }; 

template<class T, class U> 
struct missing_virtual_destructor_default_delete<T, U, false> 
{ static const bool value = false; }; 

template<class Deleter, class U> 
struct missing_virtual_destructor 
{ static const bool value = false; }; 

template<class T, class U> 
struct missing_virtual_destructor< ::boost::movelib::default_delete<T>, U > 
    : missing_virtual_destructor_default_delete<T, U> 
{}; 

} //namespace move_upmu { 
} //namespace boost { 

#endif //#ifndef BOOST_MOVE_UNIQUE_PTR_DETAIL_META_UTILS_HPP

Source

2017-04-17 Dinesh

Quel que soit le problème que vous avez, ce n'est pas dans le fichier d'en-tête Boost. Quel compilateur utilisez-vous? Quelle commande * utilisez-vous pour construire? Quelle version du compilateur utilisez-vous? –

en essayant de le compiler pour RTOS QNX en utilisant QCC. Je compile directement à partir de QNX Momentics IDE ... essayant de construire pour la famille de processeurs ARM .. je suis complètement nouveau à ce RTOS et Embedded .. – Dinesh

ajouter simplement

#undef I

avant tout endroit où Boost utilise I comme argument de modèle et vous obtenez cette erreur. Le problème est que QNX complex.h définit une macro appelée I et Boost utilise I comme arguments de modèle dans certains en-têtes:

template<class T, std::size_t I, unsigned N>

les substituts du compilateur I avec la définition de macro provenant complex.h.

J'ai discuté de ce problème en détail dans mon blog: https://cppisland.wordpress.com/2018/03/04/compiling-boost-on-qnx-a-tale-of-why-modules-are-needed-in-c/

Source

2018-03-04 09:57:54

« _FCbuild » ne peut pas être utilisé en fonction - c/C++ erreur de code

Répondre

Questions connexes