예제 #1
0
 concept bool D() { return C<T>() and __is_empty(T); }
예제 #2
0
파일: memfun-err.C 프로젝트: ChenBoTang/gcc 
 concept bool D() { return __is_empty(T); }
예제 #3
0
bool tde1 = __has_trivial_destructor(I); // { dg-error "incomplete type" }
bool tde2 = __has_trivial_destructor(C[]);
bool tde3 = __has_trivial_destructor(I[]); // { dg-error "incomplete type" }
bool tde4 = __has_trivial_destructor(void);
bool tde5 = __has_trivial_destructor(const void);

bool abs1 = __is_abstract(I); // { dg-error "incomplete type" }
bool abs2 = __is_abstract(C[]);
bool abs3 = __is_abstract(I[]); // { dg-error "incomplete type" }
bool abs4 = __is_abstract(void);
bool abs5 = __is_abstract(const void);

bool pod1 = __is_pod(I); // { dg-error "incomplete type" }
bool pod2 = __is_pod(C[]);
bool pod3 = __is_pod(I[]); // { dg-error "incomplete type" }
bool pod4 = __is_pod(void);
bool pod5 = __is_pod(const void);

bool emp1 = __is_empty(I); // { dg-error "incomplete type" }
bool emp2 = __is_empty(C[]);
bool emp3 = __is_empty(I[]); // { dg-error "incomplete type" }
bool emp4 = __is_empty(void);
bool emp5 = __is_empty(const void);

bool pol1 = __is_polymorphic(I); // { dg-error "incomplete type" }
bool pol2 = __is_polymorphic(C[]);
bool pol3 = __is_polymorphic(I[]); // { dg-error "incomplete type" }
bool pol4 = __is_polymorphic(void);
bool pol5 = __is_polymorphic(const void);
예제 #4
0
파일: traits.hpp 프로젝트: Luegg/origin 
 concept bool
 Empty_type() { return __is_empty(T); }
예제 #5
0
 bool
 f()
 { return !!__is_empty(T); }
예제 #6
0
    bool
    f()
    { return !!__is_empty(T); }
  };

template<typename T>
  class My2
  {
  public:
    static const bool trait = __is_empty(T);
  };

template<typename T>
  const bool My2<T>::trait;

template<typename T, bool b = __is_empty(T)>
  struct My3_help
  { static const bool trait = b; };

template<typename T, bool b>
  const bool My3_help<T, b>::trait;

template<typename T>
  class My3
  {
  public:
    bool
    f()
    { return My3_help<T>::trait; }
  };
예제 #7
0
class DefaultDeleter<T[]> {
    constexpr DefaultDeleter() = default;
    constexpr DefaultDeleter(const DefaultDeleter&) = default;

    void operator()(T* ptr) const {
        static_assert(sizeof(T) > 0, "Can't delete incomplete type");
        delete[] ptr;
    }
};

/*
 * UniquePointer members are stored in this seperate class in order to employ
 * empty base class optimization for the deleter object (so that empty deleters
 * have no memory overhead).
 */
template<class T, class Deleter, bool = __is_empty(Deleter) && !__is_final(Deleter)>
class UniquePointerData : private Deleter {
public:
    UniquePointerData(T* ptr, Deleter deleter) : Deleter(deleter), pointer(ptr) { }

    T*& ptr()                      { return pointer; }
    const T*& ptr() const          { return pointer; }

    Deleter& deleter()             { return *this; }
    const Deleter& deleter() const { return *this; }

private:
    T* pointer;
};

template<class T, class Deleter>