Bonjour,

Alors voilà le passage de Visual.Net 2002 à 2003 est une catastrophe.
Ce code qui fonctionnait très bien avant retourne désormais l'erreur suivante :

SimpleLink.h(59) : fatal error C1001: ERREUR INTERNE DU COMPILATEUR
(fichier du compilateur 'msc1.cpp', ligne 2701)
Choisissez la commande Support technique du menu ? (Aide) de Visual C++
ou ouvrez le fichier d'aide du Support technique pour plus d'informations
J'ai trouvé ceci sur microsoft.com :
http://support.microsoft.com/default...b;en-us;829604

Mais je n'arrive pas à trouver le problème, si quelqu'un d'experimenté ou qui a eu le même genre de problème pouvait y jeter une petit coup d'oeuil ca serait vraiment sympa.

Merci d'avance

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#ifndef _SimpleLink_h
#define _SimpleLink_h
 
 
#include <Pool.h>
#include <map>
 
// this template class is used for bidirectionnal linking.
// When 2 instances of two different classes link each other, each side have a SimpleLink class with both classes as template arguments (in this order : Src, Dst)
 
template <class T0, class T> void Nothing(T0* A,T* B) {};
 
template <class T0, class T> 
class SimpleLink
{
protected:
  T0*      _Owner;
 
  // Destination reference pool
  Pool<T>* _ReferencePool;
 
  // Main data structure : map class permit multiple links as well as simple ones
  std::map<int,T*>  _Data;
 
  // Link callbacks declaration as static members
  static void (*_LinkCallBack)(T0*,T*) ;
  static void (*_UnlinkCallBack)(T0*,T*) ;
 
public:
 
 
  SimpleLink(T0* Owner, Pool<T>* ReferencePool);
  virtual ~SimpleLink();
 
  void Set(int Id);              // Set a link (remove former ones, add just one)
  void Add(int Id);              // Add a link (add one more, without coping with former ones)
  void Delete(int Id=NULL);      // Delete a specified link or all if NULL is passed
 
  T* get();                         // Returns the destination objet (works only for simple links)
 
  T* operator->() { return get();}; // shortcut to get()
 
 
  T* IterateValues(T* Element);     // Iterators : see Pool.h for similar behaviours
  int IterateKeys(int Element);
 
 
  static void setLinkCallBack(void (*CallBack)(T0*,T*)) { _LinkCallBack = CallBack;};
  static void setUnlinkCallBack(void (*CallBack)(T0*,T*)) { _UnlinkCallBack = CallBack;};
};
 
// Initialisation to default callbacks
 
template <class T0, class T> void (*SimpleLink<T0,T>::_LinkCallBack)(T0*,T*) = Nothing; //-> C'EST ICI QU'APPARAIT L'ERREUR
 
template <class T0, class T> void (*SimpleLink<T0,T>::_UnlinkCallBack)(T0*,T*) = Nothing; //-> ET ICI AUSSI
 
template <class T0, class T> SimpleLink<T0,T>::SimpleLink(T0* Owner, Pool<T>* ReferencePool)
{
  _Owner = Owner;
  _ReferencePool = ReferencePool;
}
 
template <class T0, class T> SimpleLink<T0,T>::~SimpleLink()
{
  if (_Data.size())
  {
    // Should never be here, unlink macro must be called before deleting the object....
    int foo=0;
  }
}
 
template <class T0, class T> void SimpleLink<T0,T>::Set(int Id)
{
  Delete();
  Add(Id);
}
 
template <class T0, class T> void SimpleLink<T0,T>::Add(int Id)
{
  T* temp = _ReferencePool->Find(Id);
  _Data[Id] = temp;
  (*_LinkCallBack)(_Owner,temp);
}
 
template <class T0, class T> void SimpleLink<T0,T>::Delete(int Id)
{
  std::map<int,T*>::iterator  temp;
 
  if (Id)
  {
    temp = _Data.find(Id);
    (*_UnlinkCallBack)(_Owner,temp->second);
    _Data.erase(temp);
  }
  else
  {
    for (temp = _Data.begin(); temp != _Data.end(); temp++)
    {
      (*_UnlinkCallBack)(_Owner,temp->second);
    }
  _Data.clear();
  }
}
 
template <class T0, class T> T* SimpleLink<T0,T>::get()
{
  if (!(_Data.size()))
    return NULL;
  else
    return _Data.begin()->second;
}
 
 
template <class T0, class T> T* SimpleLink<T0,T>::IterateValues(T* Element)
{
  static std::map<int,T*>::iterator Cursor;
 
  if (Element == NULL)              // If null given, we start from the begining
  {
    Cursor = _Data.begin();
 
    if (Cursor == end())
      return NULL;
    else
      return Cursor->second;
  }
  else
  {
    if (Element == Cursor->second)  // If it isn't given back next one, must find it first
    {
      Cursor =  _Data.begin();
      while ((Cursor != _Data.end()) && (Cursor->second != Element))
        Cursor++;
 
      if (Cursor == end())
        return NULL;
    }
 
    if ((++Cursor) == _Data.end()) 
    {
      return NULL;
    }
    else
    {
      return Cursor->second;
    }
  }
}
 
template <class T0, class T> int SimpleLink<T0,T>::IterateKeys(int Element)
{
  static std::map<int,T*>::iterator Cursor;
 
  if (Element == 0)              // If null given, we start from the begining
  {
    Cursor = _Data.begin();
 
    if (Cursor == _Data.end())
      return NULL;
    else
      return Cursor->first;
  }
  else
  {
    if (Element == Cursor->first)  // If it isn't given back next one, must find it first
    {
      Cursor =  _Data.find(Element);
 
      if (Cursor == _Data.end())
        return NULL;
    }
 
    if ((++Cursor) == _Data.end()) 
    {
      return NULL;
    }
    else
    {
      return Cursor->first;
    }
  }
}
 
 
#endif