1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
#include <vcl_compiler.h>
// ------------------------------------------------
// this *does* work for SGI CC 7.2.1 -- fsm
template <class T>
struct X
{
int x;
X();
// declaration of static template member.
static X<T> *pl;
};
template <class T>
X<T>::X() : x(1728) { }
// definition (not specialization) of static template member.
template <class T>
X<T> *X<T>::pl = 0;
// explicit instantiation of class also instantiates statics.
template struct X<int>;
// ------------------------------------------------
struct A
{
int x;
mutable int y;
A() : x(0), y(0) { }
void f() { ++ x; }
void g() const { ++ y; }
};
// ------------------------------------------------
#include <vcl_iostream.h>
void vcl_test_implicit_instantiation(int n);
int test_compiler_main(int /*argc*/,char* /*argv*/[])
{
int result = 0;
vcl_cout << "Testing static template member..." << vcl_flush;
if ( X<int>::pl == 0 ) {
vcl_cout << " PASSED" << vcl_endl;
} else {
vcl_cout << "**FAILED**" << vcl_endl;
result = 1;
}
// If it links, it passed!
vcl_cout << "Testing implicit instantation..." << vcl_flush;
vcl_test_implicit_instantiation(100);
vcl_cout << " PASSED" << vcl_endl;
return result;
}
#if defined(VCL_USE_IMPLICIT_TEMPLATES) && VCL_USE_IMPLICIT_TEMPLATES
#include <vcl_vector.h>
#include <vcl_map.h>
#include <vcl_algorithm.h>
struct mystery_type
{
mystery_type();
mystery_type(int, float);
mystery_type(mystery_type const &);
mystery_type &operator=(mystery_type const &);
int a;
float b;
};
bool operator==(mystery_type const &, mystery_type const &);
bool operator< (mystery_type const &, mystery_type const &);
void vcl_test_implicit_instantiation(int n)
{
vcl_vector<mystery_type> v;
v.resize(n);
for (int i=0; i<n; ++i) {
v[i].a = i;
v[i].b = i/float(n);
}
v.reserve(2*n);
v.resize(n/2);
vcl_sort(v.begin(), v.end());
v = v;
v.clear();
typedef vcl_map<int, mystery_type, vcl_less<int> > map_t;
map_t m;
for (int i=0; i<n; ++i)
m.insert(map_t::value_type(0, mystery_type(i, i/float(n))));
m.clear();
}
mystery_type::mystery_type()
{ }
mystery_type::mystery_type(int a_, float b_)
: a(a_), b(b_) { }
mystery_type::mystery_type(mystery_type const &that)
: a(that.a), b(that.b) { }
mystery_type &mystery_type::operator=(mystery_type const &that)
{ a = that.a; b = that.b; return *this; }
bool operator==(mystery_type const &x, mystery_type const &y)
{ return (x.a == y.a) && (x.b == y.b); }
bool operator< (mystery_type const &x, mystery_type const &y)
{ return (x.a < y.b) || ((x.a == y.a) && (x.b < y.b)); }
#else
void vcl_test_implicit_instantiation(int) { }
#endif
|
