plateform stringclasses 1
value | repo_name stringclasses 2
values | name stringlengths 1 78 | ext stringclasses 2
values | path stringlengths 15 1.11k | size int64 1 8.55M | source_encoding stringclasses 11
values | md5 stringlengths 32 32 | text stringlengths 0 8.49M |
|---|---|---|---|---|---|---|---|---|
google | chromium | using6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/using6.C | 168 | utf_8 | 6bc8a704452336d9d0ee978fef2a7f60 | namespace foo {
template<typename T>
struct A {};
}
namespace bar {
template<typename T>
struct A {};
}
namespace foo {
using bar::A; // { dg-error "" }
}
|
google | chromium | crash72 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash72.C | 360 | utf_8 | 5af3f62d9558cd52f4d5aa70db89dd19 | // PR c++/29225
// { dg-do compile }
template <typename L, typename R> bool operator< (L x, R y);
struct T { int t (); };
class S {};
struct U
{
typedef int (T::* M) ();
M m;
bool operator() (S &x)
{
T a;
return (a.*m) < x; // { dg-error "invalid use of non-static member" }
}
};
void foo (S... |
google | chromium | meminit1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/meminit1.C | 149 | utf_8 | d138b62e79d7c32ba8e727ff12569de0 | // { dg-options "-std=gnu++98" }
template <class T >
struct S
{
S() : S() {} // { dg-error "base" }
};
S<int> s; // { dg-message "instantiated" }
|
google | chromium | crash39 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash39.C | 214 | utf_8 | 30bbbe26494a0bd1a56a703fe4aae882 | // PR c++/22405
template <typename T> void foo(T &arg) { // { dg-error "declared" }
arg+=1;
}
template <typename T> void foo(T &arg) { // { dg-error "redefinition" }
arg+=2;
}
template void foo(float &arg);
|
google | chromium | vtable1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/vtable1.C | 315 | utf_8 | 98fb9a7526b5989b48ce49e7131f8f76 | // Test that vtables are set up properly for constructors and destructors
// of template classes.
// { dg-do run }
int r;
template <class T>
struct A {
virtual void f () { }
A() { f (); }
~A() { f (); }
};
struct B : public A<int> {
virtual void f () { ++r; }
};
int main ()
{
{ B b; }
return r;
}
|
google | chromium | explicit2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/explicit2.C | 128 | utf_8 | 44f3a8f925589bae9dc773b19a3fd2de | struct X {
template <class B> void foo(B);
};
template <class D>
void bar() {
X().foo<D>(1);
}
template void bar<int> ();
|
google | chromium | arg1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/arg1.C | 309 | utf_8 | 7a85bf47a7ccf37365dc9d0ed5813e3e | // { dg-do compile }
// PR 9978. We rejected a constant expression.
enum { val = 1 };
template <class T>
struct Bar
{
static const int A = val;
static const int B = A + 1;
}; |
google | chromium | operator7 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/operator7.C | 142 | utf_8 | 98c4cd89cdbe74a78e512f93f452daa8 | //PR c++/27493
// { dg-options "-std=gnu++98" }
template<operator T> void foo() // { dg-error "before|template" }
{
struct A {};
}
|
google | chromium | dtor2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/dtor2.C | 96 | utf_8 | 71d10b5b4cd6cb6cb8f6be930603b8e8 | struct Foo
{
template <int i>
~Foo() {} // { dg-error "" }
};
int main()
{
Foo f;
}
|
google | chromium | typename17 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/typename17.C | 182 | utf_8 | 81aeb9e1a8d50ce9fb2161d860dc83fa | // { dg-do compile }
// This should fail as A::foo<0> is not a typename at all.
struct A
{
template<int> void foo(int i)
{
typename A::foo<0>(i1); // { dg-error "" }
}
};
|
google | chromium | koenig5 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/koenig5.C | 524 | utf_8 | 02dae2280971fe5ff910e6472b7a407a | // { dg-do compile }
// Contributed by David Abrahams <dave at boost-consulting dot com>
// PR c++/14143: Koenig lookup should only look into template arguments only
// if the argument is a template-id.
namespace fu
{
template <class T>
struct bar
{
struct baz {};
};
}
namespace axe
{
struct handle ... |
google | chromium | qualified-id1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/qualified-id1.C | 615 | utf_8 | b4f42285bb7e66d3c4ef4a890e194c54 | // { dg-do compile }
// PR 11922
struct A
{
template <bool> struct B;
struct C;
};
template <> struct A::B<false> {};
template <typename T> void foo()
{
T::C (); // { dg-error "parsed as a non-type|if a type is meant" }
T::template B<false>(); // { dg-error "parsed as a non-type" "non-type" }
// { dg-messa... |
google | chromium | sfinae1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/sfinae1.C | 484 | utf_8 | d4a6fe33f1456d026d068d25f316aa9c | // PR c++/14337
template <bool> struct Constraint;
template <> struct Constraint<true> { typedef int Result; };
template <typename T>
struct IsInt { static const bool value = false; };
template <>
struct IsInt<int> { static const bool value = true; };
template <typename T>
typename Constraint<IsI... |
google | chromium | sizeof2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/sizeof2.C | 281 | utf_8 | 6ebf0c32bb2f9f68d5de8a2eb380e74b | // { dg-do compile }
template<int size>
struct Foobar {
// Contents irrelevant
};
template <typename A>
struct Wrapper {
// Contents irrelevant
};
template <typename A>
Foobar<sizeof(Wrapper<A>)> *
compiler_bug (A)
{
return 0;
}
int main()
{
compiler_bug(1);
}
|
google | chromium | defarg2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/defarg2.C | 127 | utf_8 | 21ce3e77355010aaab1b59936da8bfbb | struct X {
X ();
};
template <int> struct O {
struct I {
I (const X & = X());
};
};
template struct O<2>;
|
google | chromium | nontype6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/nontype6.C | 456 | utf_8 | 2e2a05523958d5aa3d0c12c592bceb37 | // { dg-do compile }
// Origin: <v dot haisman at sh dot cvut dot cz>
// PR c++/13957: Improved error message for type in template (when non-type
// is expected).
template <class T>
struct A
{
typedef int type;
};
template <class T>
void func(void)
{
(void)A<T>::type(); // { dg-error "non-type" "non-type" }
// ... |
google | chromium | canon-type-3 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/canon-type-3.C | 362 | utf_8 | b62e207ee0e30db17c7ebfec8f4afd39 | // Origin PR c++/39754
// { dg-do "compile" }
template<typename> struct A ;
template<typename T , typename = A<T> > struct B { } ;
template<class W , class > struct D
{
typedef W X ;
typedef X (FP) ();
A<FP&> a ;
} ;
template < class Y > struct E
{
typedef Y (FP) ();
B<FP&> b ;
} ;
E < int > e ; |
google | chromium | new8 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/new8.C | 263 | utf_8 | b24f740838d028187b26372fe5358fca | // PR c++/34336
// { dg-do compile }
struct A;
template <class T>
struct S
{
T *m;
T &operator* () { return *m; }
};
struct B
{
B (const A &);
};
template <class T>
struct C
{
C ();
S<A> c;
};
template <class T>
C<T>::C ()
{
B *b = new B (*c);
}
|
google | chromium | crash21 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash21.C | 915 | utf_8 | e11ee09376a4af9fd0b4e8a0131f1ad5 | // { dg-do compile }
// PR c++/16706: Dependent type calculation during access checking
template <typename> struct B {
B() throw() {}
struct S { };
static int i;
typedef unsigned short int dummy;
};
template <typename _Tp>
struct allocator: B<_Tp> {
template<typename _Tp1> struct rebind
... |
google | chromium | unify11 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/unify11.C | 451 | utf_8 | d9da96e713c167a395e4c07da7c74a15 | // Origin: PR c++/40684
// { dg-options "-std=c++0x" }
struct A
{
};
template <typename S, typename T, typename U, typename S::v = &S::v::s>
typename S::A
foo (S c, T t, U u)
{
}
struct B
{
struct C
{
template <typename U>
C (U t)
{
A a;
A b = foo (this, a, t); // { dg-error "no matching fun... |
google | chromium | friend4 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/friend4.C | 548 | utf_8 | 56e71f86759e703664c2ed50998932fd | // { dg-do compile }
// PR 109, dependent member friends
struct B
{
static int foo ();
struct N
{
static int bar ();
};
};
template <class T>
class A
{
friend int T::foo ();
friend int T::N::bar ();
private:
static int m;
};
template <class T>
class C
{
friend struct T::N;
private:
static i... |
google | chromium | non-dependent12 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/non-dependent12.C | 259 | utf_8 | c68de3013fc66d5b9ca387b1f0f294ad | template<typename T> void foo(T &t)
{
int i = static_cast<int>(t);
} |
google | chromium | spec18 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/spec18.C | 150 | utf_8 | f9db6cb49e2fa6c6968fe9e4a6f2a111 | // PR c++/17936
template<int, int N> struct A
{
void foo();
};
template<int N> struct A<1, N>
{
void foo();
};
template<> void A<1, 2>::foo();
|
google | chromium | typedef10 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/typedef10.C | 200 | utf_8 | da5e10dcd0d113f42f94806f2313be36 | // PR c++/34573
template < class Gtr_>
void compute_gr()
{
typedef int Less_chain;
struct utils {
utils(const Less_chain& lc) {};
};
utils U(1);
}
int main(void){
compute_gr<int>();
}
|
google | chromium | void11 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/void11.C | 189 | utf_8 | 334f2b6dd7bbf1694010e0f30e5058f9 | // PR c++/31446
template<void> struct A // { dg-error "valid type" }
{
template<int> friend void foo();
};
void bar()
{
foo<0>(); // { dg-error "not declared|primary-expression" }
}
|
google | chromium | qualttp6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/qualttp6.C | 339 | utf_8 | 08683258d49e31d3eb73ace3d1433c01 | // { dg-do compile }
template <template <class> class TT> class C {
};
template <class T> struct D {
C<T::template B> c; // { dg-error "no class template" }
};
struct E {
};
D<E> d; // { dg-message "instantiated" } |
google | chromium | member2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/member2.C | 254 | utf_8 | cabe816ff29ed547a0c78ab109ad97d0 | // PR c++/8660
// Bug: we were treating the definition of the non-template as a definition
// of the template, which broke.
struct BadgerBuf
{
void ReadPod();
template<class B>
void ReadPod();
};
void BadgerBuf::ReadPod ()
{ ReadPod<int> (); }
|
google | chromium | friend29 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/friend29.C | 184 | utf_8 | a0d74e429e0416fe8fd207b1ee020c7a | // PR c++/15701
template<template<int> class T> struct A : T<0>
{
void foo();
template<template<int> class U> friend void A<U>::foo();
};
template<int> struct B {};
A<B> a;
|
google | chromium | instantiate7 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/instantiate7.C | 258 | utf_8 | cb17733e32e1d70e72ba5449d93b192f | // PR c++/19498
// { dg-do compile }
template<typename T> struct A
{
template<T&> struct B; // { dg-error "reference to void" }
};
A<void> a; // { dg-message "instantiated" } |
google | chromium | init1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/init1.C | 233 | utf_8 | f30fe425de51d4cb2ab5ff05b71d616a | // { dg-do compile }
// PR c++/9457: ICE tsubst'ing initializers in templates.
template <typename> void foo (int count) {
int i = {count};
}
template void foo<int> (int); |
google | chromium | spec12 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/spec12.C | 472 | utf_8 | 5887f7286f7e8d72346052184c20f45e | // { dg-do compile }
// Contributed by: Wolfgang Bangerth <bangerth at dealii dot org>
// PR c++/14409: Accepts invalid function signature for explicit instantiation
struct X
{
template <typename U>
void foo (U) {}
template <typename U>
void foo_const (U) const {}
};
template void X::foo (int);
... |
google | chromium | crash85 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash85.C | 274 | utf_8 | fac18fbcfe10c67843c28437a6b92d3c | // Origin: PR c++/37142
// { dg-do compile }
template<typename T, const T a, template <typename U, U u> class W> struct A {};
template<typename T, const T t> struct B {};
int
main ()
{
A<long, 0, B> a;
return 0;
} |
google | chromium | repo6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/repo6.C | 368 | utf_8 | e6ff031ac5c6f3902abdc8613e547a95 | // PR c++/34178
// { dg-options "-frepo" }
// { dg-final { cleanup-repo-files } }
// { dg-require-host-local "" }
template<typename T>
class A
{
private:
static const int x;
static int y;
public:
int getX () { return x + y; }
};
template<typename T> const int A<T>::x = 0;
template<typename T> int A<T>::y = 0;
... |
google | chromium | redecl4 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/redecl4.C | 144 | utf_8 | cd21403ce71916cfa4b5c75f6da549d9 | // PR c++/28710
// { dg-do compile }
template<int> union A; // { dg-error "previous" }
struct A; // { dg-error "non-template" }
|
google | chromium | memfriend6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/memfriend6.C | 856 | utf_8 | 1e93d7f7d38f19d9cc623f9113275868 | // { dg-do compile }
// Member function of class template as friend
// Erroneous case: mismatch during declaration
template <class T> struct A {
template <class U> void f(U); // { dg-error "candidate" }
void g(); // { dg-error "candidate|with" }
void h(); // { dg-error "candidate|with" }
void i(int); ... |
google | chromium | restrict1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/restrict1.C | 147 | utf_8 | 9e9322d04add76d1f767de02d143704b | // PR c++/6392
// Bug: We tried to make the array restricted, which doesn't make sense.
template <class T>
class bob
{
T * __restrict a[50];
};
|
google | chromium | error1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/error1.C | 350 | utf_8 | 21c90677bbfb74c29a346183dc8bc5a3 | // { dg-do compile }
// PR c++ 10219. ICE
template <class T> void make_pair(T x);
void foo(){
struct fps_chan_ID fps; // { dg-error "incomplete" "" }
make_pair(fps); // { dg-bogus "no matching function" "" }
} |
google | chromium | array16 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/array16.C | 168 | utf_8 | 53d279c2d582bce6b0ed40786c57eb25 | // PR c++/28886
template<typename> struct A;
template<typename T, int N> struct A<T[N]> {};
template<typename T, int N> struct A<const T[N]> {};
A<const int[1]> a;
|
google | chromium | spec6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/spec6.C | 189 | utf_8 | b03b7960945086593b8859887c9f2b8e | template <bool, int> struct X {};
template <bool C> struct X<C,1> {
typedef double* type;
type foo () const;
};
template <bool C>
typename X<C,1>::type
X<C,1>::foo () const {}
|
google | chromium | friend6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/friend6.C | 914 | utf_8 | d16da0e6f160e02bc23c4d98080f1644 | // { dg-do compile }
namespace boost_no_member_template_friends{
template <class T>
class foobar;
template <class T>
class foo
{
private:
template<typename Y> friend class foobar;
template<typename Y> friend class foo;
template<typename Y> friend bool must_be_friend_proc(const foo<Y>& f);
int i;
public:
... |
google | chromium | assign1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/assign1.C | 145 | utf_8 | 63a5e3d5f634ef4eb13aa4a9d62a8cd7 | // PR c++/16623
template <int N>
struct C
{
C& operator= (int);
};
template <int N>
C<N>& C<N>::operator= (int)
{
return *this;
}
C<0> a;
|
google | chromium | crash84 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash84.C | 364 | utf_8 | c43dd07e18bb076a009c04c9ed9dd5ce | // Origin PR c++/35405
// { dg-do compile }
template<typename T> struct a
{
template <template <typename> class C, typename X, C<X>* =0>
struct b // { dg-error "class C' is not a template|is not a valid type" }
{
};
};
void
foo ()
{
a<int> v; // { dg-message "instantiated from here" }
} |
google | chromium | redecl1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/redecl1.C | 75 | utf_8 | c7309345696ac164222361961daab266 | // PR c++/15025
template <int> struct X;
struct X {}; // { dg-error "" }
|
google | chromium | shift1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/shift1.C | 223 | utf_8 | 429c749d4a969d6e6782e2108d66cc72 | // PR c++/18140
// { dg-options "-std=gnu++98" }
template <int N> struct IntHolder {
static const int value = N;
};
template <int N, int S> struct ShrIntHolder {
static const int value = IntHolder< N>>S >::value;
};
|
google | chromium | spec29 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/spec29.C | 397 | utf_8 | 9b290630d01c434872c1ed3db6067a4f | // PR c++/25855
// { dg-do run }
template <typename T> int qCompare(const T *t1, const T *t2) { return 1; }
template <typename T> int qCompare(T *t1, T *t2) { return 2; }
template <typename T1, typename T2> int qCompare(const T1 *t1, const T2 *t2) {
return 3; }
template<> int qCompare(const char *t1, const char *t... |
google | chromium | typename2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/typename2.C | 632 | utf_8 | e157ec339365093c9f152c565a72d172 | // { dg-do compile }
// { dg-options "" }
// PR 5507. Overzealous implicit typename warning
template<typename _CharT>
class __ctype_abstract_base
{
typedef int mask;
};
template<typename _CharT>
class ctype : public __ctype_abstract_base<_CharT>
{
typedef typename ctype::mask mask;
};
template<typename _CharT>
clas... |
google | chromium | arg6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/arg6.C | 240 | utf_8 | f90e567b7331a6236abd917963c61a0f | // PR c++/33744
// { dg-do run }
template <bool B> struct A { bool b; A() : b(B) {}; };
A<bool(1)> a;
A<bool(1<2)> b;
A<(bool)(2>1)> c;
A<bool((2>1))> d;
A<bool(2>1)> e;
int
main ()
{
return (a.b && b.b && c.b && d.b && e.b) ? 0 : 1;
}
|
google | chromium | mangle1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/mangle1.C | 292 | utf_8 | 33119bbc7489f718bc456a2baae44253 | // PR c++/17324
// { dg-do assemble }
template<int, typename T> struct A
{
template<int I> void foo(const A<I,T>&) {}
};
template<typename> struct B
{
template<int J> void bar(const A<J,B>&);
void baz() { A<0,B>().foo(A<0,B>()); }
};
template struct B<void>;
template struct B<int>;
|
google | chromium | typename14 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/typename14.C | 407 | utf_8 | 7dd8b9bc6da8c8f42250a913e3dbff25 | // { dg-do compile }
template <typename T> struct A
{
typedef const T X;
struct B;
};
template <typename T> struct A<T>::B
{
typedef volatile typename A<T>::X Y;
T const volatile *Foo ();
};
template<typename T>
typename A<T>::B::Y *A<T>::B::Foo ()
{
return 0;
} |
google | chromium | static26 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/static26.C | 249 | utf_8 | 2bfba281dfdf39292b16309d13ce403d | // PR c++/28016
// { dg-final { scan-assembler-not "computed" } }
template<class T1, class T2>
struct scalar_divides_assign {
static const bool computed ;
};
template<class T1, class T2>
const bool scalar_divides_assign<T1,T2>::computed = true;
|
google | chromium | pr28284 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/pr28284.C | 242 | utf_8 | 10a1cc60b3d92d61e1b34b9ac481d289 | /* { dg-do compile } */
template<int> struct A
{
static const int i=x; /* { dg-error "was not declared in this scope" } */
static const int j, k;
};
template<int N> const int A<N>::j = i;
template<int N> const int A<N>::k = j;
A<0> a;
|
google | chromium | static19 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/static19.C | 458 | utf_8 | 0cac9c7a335a2eb97f02d3b04f03aa6a | // PR c++/24275
template <bool val> struct bool_var {
static const bool value = val;
};
namespace is_inc_ {
struct any {
template <class T> any(T const&);
};
int operator++(any const&);
template <class T> struct impl {
static T &x;
static const bool value = sizeof(++x) == 1;
};
}
template<ty... |
google | chromium | crash1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash1.C | 335 | utf_8 | ff8577ac97f88f47b1257f3d5c6a4c9a | // { dg-do compile }
// PR 5125. ICE
class S
{
public:
template <class I> void Foo(int (*f)(S& o) );
};
template <class I>
void S::Foo(int (*f)(TYPO&o) ) // { dg-error "Foo|f|TYPO|o" }
{
} |
google | chromium | fntry1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/fntry1.C | 442 | utf_8 | 8f101d84c90c958381606b762e3df298 | // PR c++/26433
// { dg-do link }
int get_int()
{
throw 1;
return 0;
}
template <class _T> class Test
{
public:
Test()
try
: i(get_int())
{
i++;
}
catch(...)
{
// Syntax error caused by undefined __FUNCTION__.
const char* ptr = __FUNCTION__;
}
private:
int i;
_T t;
};
int m... |
google | chromium | array1-2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/array1-2.C | 418 | utf_8 | 075227803fea6455eb958b3d2d173e9b | // { dg-do compile }
// { dg-options "-fabi-version=2" }
// PR c++/12774 Array domains compared unequal
void Foo(double r[3][3])
{
}
void Baz()
{
double m[3][3];
Foo(m);
}
template <class T>
void Bar()
{
double m[3][3];
Foo(m);
}
int main()
{
Baz();
Bar<int>();
return 0;
} |
google | chromium | friend7 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/friend7.C | 377 | utf_8 | 1d4f923241bfe8578940f39c34f80d7c | // { dg-do compile }
template <typename V>
struct b
{
template <typename T>
class a
{
template <typename>
friend class a;
T t_;
public:
a() {}
a(a<T *> const &);
};
};
template <typename V>
template <typename T>
b<V>::a<T>::a(a<T *> const &rhs): t_(*rhs.t_)
{}
int
f ()
{
b<void *>... |
google | chromium | using12 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/using12.C | 113 | utf_8 | d401bee05fb2dd315aae324d855a8f7a | struct A {
};
template <typename T>
struct S : public A {
using A::operator(); // { dg-error "no member" }
};
|
google | chromium | spec31 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/spec31.C | 122 | utf_8 | 5f4ca65174fe2a4c7ed7bfb4fa8c89d5 | // PR c++/28058
template<int> struct A
{
A() {}
};
A<0> a;
template<> A<0>::A() {} // { dg-error "specialization" }
|
google | chromium | incomplete3 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/incomplete3.C | 166 | utf_8 | b6192cd189e5459a84384348bf07ab8a | // PR c++/27315
// { dg-do compile }
struct A; // { dg-error "forward declaration" }
template void A::foo<0>(); // { dg-error "before|incomplete" }
|
google | chromium | overload2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/overload2.C | 267 | utf_8 | 55cb3ca88be88700e7e00981ae5c08c6 | template <class T, int (T::*)> struct foo;
template <class T>
int f(foo<T,&T::ob_type>*);
template <class T>
char* f(...);
struct X { int ob_type; };
struct Y { char* ob_type; };
int x = f<X>(0);
char* y = f<Y>(0);
char* z = f<int>(0);
int main() { return 0; }
|
google | chromium | qual2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/qual2.C | 427 | utf_8 | 4bcab05d2626fd45890af6154fa22221 | // { dg-do run }
// PR9415. Forgot a lookup was scoped
int here;
int there;
struct B
{
virtual int activate() {return !here++;}
};
template <class K>
struct TPL : public B
{
int activate()
{
return !there++ && B::activate();
}
};
int main ()
{
TPL<int> i;
return !i.activate ();
} |
google | chromium | stmtexpr1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/stmtexpr1.C | 150 | utf_8 | 53fcc90b25ad8744232fbb7b915d3d89 | // PR c++/17404
// { dg-do compile }
// { dg-options "" }
template <int> void foo ()
{
__builtin_expect (({0;}), 1);
}
template void foo<1> ();
|
google | chromium | call2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/call2.C | 170 | utf_8 | e459df3ddd572b111e8694073c95e5b9 | // PR c++/13592
struct S {
void operator()(int);
};
struct A {
template <typename> void foo();
S s;
};
template <typename> void A::foo() {
s(0);
}
|
google | chromium | non-dependent3 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/non-dependent3.C | 312 | utf_8 | 9c0fc4f566e5de8ff0339df3c3ef274d | //PR c++/11071
// Used to ICE
template <bool b> struct X {
template <typename T>
static int* execute(T* x) { return x; }
};
template <typename T> void foo() {
static bool const same = true;
X<same>::execute ((int*)0);
}
template void foo<int> (); |
google | chromium | conv3 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/conv3.C | 663 | utf_8 | be5017725e9889a47d07ba0d3a3464ff | // { dg-do run }
// PR 4361. Template conversion operators were not overloaded.
template <typename T> struct C
{
operator T ()
{
return 0;
}
template <typename T2> operator T2 ()
{
return 1;
}
int Foo ()
{
return operator T ();
}
template <typename T2> int Baz ()
{
return static_c... |
google | chromium | crash17 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash17.C | 223 | utf_8 | 78327c2d24f8befdc8bd1b4f71aa2928 | template <int I>
struct A {
};
template <typename T>
struct B {
typedef typename T::type type;
static const type j = T::j;
A<j> b;
};
struct C {
typedef int type;
static const int j = 3;
};
int i = B<C>::j;
|
google | chromium | access20 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/access20.C | 295 | utf_8 | 97435ae64eee527d6ffaaa5dcc63f78e | // PR c++/29470
template <typename T> struct B
{
protected:
T v; // { dg-error "protected" }
};
template <typename T> struct D : B<T>
{
protected:
using B<T>::v;
};
int main()
{
D<int> d;
d.v = 0; // { dg-error "context" }
return 0;
}
|
google | chromium | typedef1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/typedef1.C | 443 | utf_8 | 3c8d3538984363bd4ff0ecceec6b5f59 | // { dg-do compile }
// PR 72
template <typename T> struct A
{
typedef T type;
};
template <typename T> struct B
{
typedef int xxx; // { dg-error "" }
typedef T xxx; // { dg-error "" }
typedef typename A<T>::type xxx; // { dg-error "" }
typedef A<int>::type xxx; // { dg-error "" }
};
B<int> good; |
google | chromium | crash50 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash50.C | 139 | utf_8 | cba5348987312926d5bd6854ffc13bb6 | // PR c++/27398
// { dg-do compile }
struct A
{
template<int> void* foo(; // { dg-error "primary-expression|initialization|static" }
};
|
google | chromium | using1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/using1.C | 562 | utf_8 | 36bc33b0a7d4f4c6efc1f83c1b6bf13b | // { dg-do run }
// PR 9447. Using decls in template classes.
template <class T>
struct Foo {
int i;
};
struct Baz
{
int j;
};
template <class T>
struct Bar : public Foo<T>, Baz {
using Foo<T>::i;
using Baz::j;
int foo () { return i; }
int baz () { return j; }
};
int main()
{
Bar<int> bar;
bar.i = 1... |
google | chromium | non-dependent9 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/non-dependent9.C | 273 | utf_8 | d2f711147c60030525ec70290e759fca | // { dg-do compile }
// Two-phase name lookup for address of member:
// Overloading function
struct S
{
int f();
int f(int);
};
template<int (S::*p)()>
struct X
{};
template <class T>
struct Foo
{
X<&S::f> x;
}; |
google | chromium | memfriend16 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/memfriend16.C | 614 | utf_8 | 3c8d60eb2a84a4ac96ec9e16cadb0848 | // { dg-do compile }
// Nested class of class template as friend
template<class T> struct A
{
template <class U> struct B1
{
};
template <class U> struct B2
{
void f();
};
};
class C {
int i; // { dg-error "private" }
template<class T> template <class U> friend struct A<T>::B1;
};
template<class T> ... |
google | chromium | ptrmem1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/ptrmem1.C | 599 | utf_8 | 30d2a35742944aa3c421d0b6d2b41781 | // { dg-do compile }
// PR 3716 tsubsting a pointer to member function did not create a
// pointer to member function.
template <class C, class T, T C::*M>
struct Closure
{
T operator() (C & c) const { return (c.*M); }
};
template <class C, class T, T (C::* M)()>
struct Closure<C, T (), M>
{
T operator()(C & c) con... |
google | chromium | ptrmem6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/ptrmem6.C | 199 | utf_8 | c341261c190bf4a6a9280b8bf11ebfd2 | struct S {};
void g(int S::**);
template <typename T>
void f (int T::* volatile *p) {
g(p); // { dg-error "conversion" }
}
template void f(int S::* volatile *); // { dg-message "instantiated" }
|
google | chromium | unify10 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/unify10.C | 1,742 | utf_8 | 510fd3ce84e62045e22325b3b40e2abb | // { dg-do compile }
// Origin: Wolfgang Bangerth <bangerth at ticam dot utexas dot edu>
// and Rene Fonseca <fonseca at mip dot sdu dot dk>
// PR c++/8271: Check cv-qualifiers while unifying pointer to member
// functions.
struct MyClass {
void mMethod() throw() {}
void cMethod() const throw() {}
void vMet... |
google | chromium | sfinae3 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/sfinae3.C | 307 | utf_8 | df70bad533a0f47bbceddb5ae41c6a53 | // PR c++/24671
// { dg-options "" }
template<typename> struct A
{
typedef int X;
static const int i = 0;
};
template<typename> struct B
{
B(const B&); // { dg-message "candidate" }
typedef typename A<char[A<B>::i]>::X Y;
template<typename T> B(T, Y); // { dg-error "call" }
};
B<int> b(0,0);
|
google | chromium | dtor4 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/dtor4.C | 178 | utf_8 | 6e56714a3e1899ea002e689d9f32a53f | // PR c++/19440
// { dg-do compile }
template<int> struct A
{
~A<0>(); // { dg-error "parse error|declaration" }
}; |
google | chromium | non-dependent13 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/non-dependent13.C | 146 | utf_8 | 40b38a3d73d53481f9e1570a38ed4eab | // PR c++/26266
template <int I>
struct S;
template <int I>
void f() {
if (const int i = 3) {
S<i>::j; // { dg-error "incomplete" }
}
}
|
google | chromium | ttp22 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/ttp22.C | 239 | utf_8 | b29aec661b5b00820f2fcebc0dad251e | // PR c++/28860
// { dg-do compile}
template<template<int> class A>
class A<0>; // { dg-error "shadows template template parameter" }
template<template<int> class B>
class B<0> {}; // { dg-error "shadows template template parameter" }
|
google | chromium | error8 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/error8.C | 107 | utf_8 | 087bbcdc150fa765a03be550dd7193ce | // PR c++/11116
template <typename T> struct S {};
void f() {
throw S (); // { dg-error "template" }
}
|
google | chromium | sfinae4 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/sfinae4.C | 862 | utf_8 | 14c823d80f9e1e49b0085a00aa357406 | // DR 339
//
// Test of the use of free functions with SFINAE
void foo(int) { }
template<typename T> void foo(T*) { }
typedef char yes_type;
struct no_type { char data[2]; };
template<typename T> T create_a();
template<bool, typename T = void> struct enable_if { typedef T type; };
template<typename T> struct enable_... |
google | chromium | unify6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/unify6.C | 476 | utf_8 | 63e91a546ca33b6fb3126c637052a11d | void Baz ();
template <typename T> void Foo1 (T *); // #1
template <typename T> void Foo1 (T const *a) {a (1);} // #2
template <typename T> T const *Foo2 (T *);
template <typename T> void Foo3 (T *, T const * = 0);
void Bar ()
{
Foo1 (&Baz); // #1
Foo2 (&Baz);
Foo3 (&Baz);
Foo3 (&Baz, &Baz); // { dg-error "no m... |
google | chromium | call7 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/call7.C | 285 | utf_8 | 653870efc0beb2f7f74e9279886c39eb | // Origin: PR c++/17395
// { dg-do "compile" }
template<int> struct X { };
void fu(int a, X<sizeof(a)>) { }
template<class T>
void bhar(T a, X<sizeof(a)>) { }
int
main()
{
int x;
X<sizeof(int)> y;
fu(x, y);
bhar(x, y);
} |
google | chromium | sfinae14 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/sfinae14.C | 2,421 | utf_8 | 8cbf9e9ec798570f590ac39820557fc3 | // DR 339
//
// Test of the use of the new and new[] operators with SFINAE
// Boilerplate helpers
typedef char yes_type;
struct no_type { char data[2]; };
template<typename T> T create_a();
template<typename T> struct type { };
template<bool, typename T = void> struct enable_if { typedef T type; };
template<typename... |
google | chromium | error37 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/error37.C | 264 | utf_8 | 34ab2aefdfc2ee66c4a1c5d1830304e9 | // { dg-do compile }
// PR C++/29388
// We used to ICE in is_ancestor because we would use int as the context of foo
// but that is invalid.
template<int> struct A
{
typedef int T;
void foo();
};
template<int N> void A<N>::T::foo() {} // { dg-error "" }
|
google | chromium | friend35 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/friend35.C | 347 | utf_8 | e1e2f22ab1205ab9d092f2b388d3e071 | // { dg-do compile }
// PR c++/4403: Incorrect friend class chosen during instantiation.
template <typename T>
struct A
{
struct F;
};
template <typename T>
struct B : A<T>
{
friend struct F;
private:
int priv;
};
struct F
{
void func(void)
{
B<int> b;
b.priv = 0;
}
}; |
google | chromium | ctor6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/ctor6.C | 88 | utf_8 | 25d3511fe5a378afd592b4563e115a7c | // PR c++/25663
template<int> struct A
{
A(int);
};
void foo()
{
A<0>(A<0>(0));
}
|
google | chromium | friend10 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/friend10.C | 833 | utf_8 | bdf8365204c19eeb87434d85b7139d2d | // { dg-do run }
// PR 5116. template instantiation can add a friend into a namespace,
// and thus change overload resolution.
#include <iostream>
static int right;
static int wrong;
struct Buggy {};
template <typename T>struct Handle
{
Handle(T* p) {}
operator bool() const { wrong++; return true; }
friend ... |
google | chromium | error26 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/error26.C | 146 | utf_8 | d6f93055afe5bb78dbd6073dd989bdef | // PR c++/32112
template<typename> struct A;
template<typename T> void foo (A<&T::template i>); // { dg-error "T::template i|mismatch|& T::i" }
|
google | chromium | crash44 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash44.C | 110 | utf_8 | 37c9686aad1de31e5858e6070db0fd76 | // PR c++/25858
namespace N {
template<int> struct A {};
}
struct B N::A<0> {}; // { dg-error "invalid" }
|
google | chromium | static13 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/static13.C | 181 | utf_8 | fe8a47b8f67dd5267646e9d0116a86ca | // PR c++/23099
struct Base {
int x;
};
template <typename T>
struct A {
static const int N = sizeof(static_cast<Base*>(T()));
};
struct Derived : Base {
A<Derived*> a;
};
|
google | chromium | crash66 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash66.C | 389 | utf_8 | e29b7df66408269c2eaea4100f6227cf | // PR c++/29535
// { dg-do compile }
template <class INDEX> struct SetRegion2D
{
struct FloodFillControl
{
struct Allocator{};
};
};
template <int DIM, class PIXELINDEX>
struct MotionSearcher
{
typedef SetRegion2D<PIXELINDEX> Region_t;
MotionSearcher (typename Region_t::FloodFillControl::Allocator &a_rAllo... |
google | chromium | local2 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/local2.C | 2,293 | utf_8 | d32b0f4cfabbf7cf6a3f55db155096d2 | template<typename T>
struct X {
double & f (const unsigned int i,
const unsigned int j);
void g (X &M);
};
template <typename T>
void X<T>::g (X &x) {
double t14 = x.f(0,0)*x.f(1,1);
double t15 = x.f(2,2)*x.f(3,3);
double t17 = x.f(2,3)*x.f(3,2);
double t19 = x.... |
google | chromium | instantiate6 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/instantiate6.C | 311 | utf_8 | 1b065aa49cdac44198ed227ed0da9cb5 | // { dg-do compile }
// PR c++/13289: ICE recursively instantiate static member data.
template <int N> struct S {
static const int C;
};
template <int N>
const int S<N>::C = S<(N+1)%2>::C;
template struct S<1>; |
google | chromium | crash24 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash24.C | 191 | utf_8 | 1cb212177b7a7b17863561096ca1b123 | // PR c++/17826
struct A
{
template<typename> static int foo();
};
template<int> struct B {};
template<typename T> void bar()
{
B<sizeof A::foo<T>()> b1;
B<sizeof A::foo<T>()> b2;
}
|
google | chromium | ctor7 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/ctor7.C | 309 | utf_8 | 0572945ccfe2a2369a8e72b22dab3d97 | // PR c++/27640
template < class T > struct refcounted :
virtual T
{
template < class A1 > refcounted (const A1 & a1) : T () { }
};
struct nfsserv {};
template < class T >
void
sfsserver_cache_alloc (int *ns)
{
new refcounted < nfsserv > (*ns);
}
void
usage ()
{
sfsserver_cache_alloc < int > ( 0);
}
|
google | chromium | array13 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/array13.C | 226 | utf_8 | 29ac13549ace1bb08c2a718d6a2f3d31 | // PR c++/20208
// { dg-do run }
// { dg-options "-O2" }
extern "C" void abort();
template <typename T>
inline void *Foo (T arg) { return &arg[0]; }
int main () {
int bry[2];
if (Foo<int[2]>(bry) != bry)
abort();
}
|
google | chromium | friend46 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/friend46.C | 177 | utf_8 | b6050fc706b8413aeac096dd69086d72 | // PR c++/27714
template<typename> struct A
{
static void* operator new(__SIZE_TYPE__);
template <typename T> friend void* A<T>::operator new(__SIZE_TYPE__);
};
A<int> a;
|
google | chromium | mem-partial1 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/mem-partial1.C | 289 | utf_8 | 20021d29d7752d6eac42fc721092a468 | // PR c++/14032
template <typename T> struct outer {
template <typename T2, typename U>
struct inner {
static int f() { return inner<T,int>::N; };
};
template <typename U>
struct inner<T,U> {
static const int N = 1;
};
};
int i = outer<int>::inner<double,int>::f();
|
google | chromium | crash4 | .C | native_client/nacl-gcc/gcc/testsuite/g++.dg/template/crash4.C | 189 | utf_8 | 4565662b8ea1b02f11db4b1627917693 | namespace NS {
struct C {};
void foo();
}
template <class T> struct X {};
template <class T> struct A {
A() { foo (X<T>()); }
void foo(X<T>);
};
template struct A<NS::C>;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.