Bonjour,

après 2 ans de COBOL, je retrouve le C++ mais avec un peu de rouille entre les doigts. L'Ecole étant bien loin, je tombe régulièrement sur des écueils de ce genre :

CVolRen.obj : error LNK2001: unresolved external symbol "unsigned char * * * * __cdecl TabAlloc(unsigned char * * * *,unsigned int,unsigned int,unsigned int,unsigned int)" (?TabAlloc@@YAPAPAPAPAEPAPAPAPAEIIII@Z)
CVolRen.obj : error LNK2001: unresolved external symbol "unsigned char * * * __cdecl TabAlloc(unsigned char * * *,unsigned int,unsigned int,unsigned int)" (?TabAlloc@@YAPAPAPAEPAPAPAEIII@Z)
CVolRen.obj : error LNK2001: unresolved external symbol "unsigned char * * __cdecl TabAlloc(unsigned char * *,unsigned int,unsigned int)" (?TabAlloc@@YAPAPAEPAPAEII@Z)


J'écris deux fichiers Tools.h /Tools.cpp dans lequel j'ai défini (entre autres) des fonctions allocations dynamiques de tableau 2,3 et 4 dimensions de tous types compatibles. Pour ce faire, j'ai défini et surdéfini 1 fonction template avec différents paramètres (cf. ci-dessous).

J'utilise ensuite ces fonctions dans une fonction membre d'une Classe CVolRen ... mais là le bât blesse : malgré l'Include, je reçois les messages cité plus haut (Visual C++ 6.0).

Je pêche forcément quelque part, mais ne maîtrise pas assez le sujet pour savoir où... Il se pourrait même que je sois parfaitement à côté de la plaque, mais comme disait mon père : il vaut mieux avoir l'air visiblement bête 5 minutes que de le rester discrètement toute sa vie. Donc, sur ce pilier de sagesse, auriez vous une idée?



Tools.h:
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
#include <stdio.h>
 
#ifndef TOOLS_H
#define TOOLS_H
 
#endif
 
//int GetSupClosestPowerOfTwo(int p_Number);
 
template <class DataType>
DataType ** TabAlloc(DataType ** p_Table, unsigned int p_Width, unsigned int p_Height);
 
template <class DataType>
DataType *** TabAlloc(DataType *** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth);
 
template <class DataType>
DataType **** TabAlloc(DataType **** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth, unsigned int p_Dim);
 
 
template <class DataType>
void TabFree( DataType ** p_Table, unsigned int p_Width, unsigned int p_Height);
 
template <class DataType>
void TabFree( DataType *** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth);
 
template <class DataType>
void TabFree( DataType **** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth, unsigned int p_Dim);
Tools.Cpp:
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
#include "StdAfx.h"
#include "Tools.h"
#include <stdlib.h>
#include <math.h>
 
 
//////========================================================================
//////========================================================================
//////=================    ALLOCATION  DYNAMIQUE      ========================
//////================= DE TABLES DE 2 À 4 DIMENSIONS ========================
//////========================================================================
//////========================================================================
 
 
template <class DataType>
DataType ** TabAlloc( DataType ** p_Table, unsigned int p_Width, unsigned int p_Height)
{
	p_Table = (DataType **) malloc(p_Width*sizeof(DataType*));
	for(int i = 0; i < p_Width; ++i)
	{
		p_Table[i] = (DataType*) malloc(p_Height*sizeof(DataType));
	}
	return DataType;
}
 
//////========================================================================
//////========================================================================
 
template <class DataType>
DataType *** TabAlloc( DataType *** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth)
{
	p_Table = (DataType ***) malloc(p_Width*sizeof(DataType**));
 
	for(int i= 0; i < p_Width; i++)
	{
		p_Table[i]= (DataType **)calloc(p_Height, sizeof(DataType*));
		for(int j= 0; j < m_Height; j++)
		{
			p_Table[i][j]= (DataType *)calloc(p_Depth, sizeof(DataType));
		}
	}
	return DataType;
}
 
//////========================================================================
//////========================================================================
 
template <class DataType>
DataType **** TabAlloc( DataType **** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth, unsigned int p_Dim)
{
	p_Table = (DataType ****) malloc(p_Width*sizeof(DataType***));
 
	for(int i= 0; i < p_Width; i++)
	{
		p_Table[i]= (DataType ***)calloc(m_Height , sizeof(DataType**));
		for(int j= 0; j < m_Height ; j++)
		{
			p_Table[i][j]= (DataType **)calloc(p_Depth  , sizeof(DataType*));
			for(int k= 0; k < p_Depth ; k++)
			{
				p_Table[i][j][k]= (DataType *)calloc(p_Dim , sizeof(DataType*));
			}
 
		}
	}
	return DataType;
}
 
 
//////========================================================================
//////========================================================================
//////=================    LIBERATION DES TABLES      ========================
//////=================          EN MEMOIRE           ========================
//////========================================================================
//////========================================================================
 
template <class DataType>
TabFree(DataType ** p_Table, unsigned int p_Width, unsigned int p_Height)
{
	for(int i = 0; i < p_Width; ++i)
	{
		free(p_Table[i]);
	}
	free(p_Table);
}
 
//////========================================================================
//////========================================================================
 
template <class DataType>
TabFree(DataType *** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth)
{
 
	for(int i= 0; i < p_Width; i++)
	{
		for(int j= 0; j < m_Height; j++)
		{
			free(p_Table[i][j]);
		}
		free(p_Table[i]);
	}
	free(p_Table);
 
 
}
 
//////========================================================================
//////========================================================================
 
template <class DataType>
TabFree(DataType **** p_Table, unsigned int p_Width, unsigned int p_Height, unsigned int p_Depth, unsigned int p_Dim)
{
 
	for(int i= 0; i < p_Width; i++)
	{
		for(int j= 0; j < m_Height ; j++)
		{
			for(int k= 0; k < p_Depth ; k++)
			{
				free(p_Table[i][j][k]);
			}
			free(p_Table[i][j]);
 
		}
		free(p_Table[i]);
	}
	free(p_Table);
 
}
CVolren.Cpp:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
#include "Tools.h"
...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
 
// Allocation dynamique des tables de texture
 
	GLubyte **   l_Plane = TabAlloc(l_Plane, p_Width, p_Height);
 
	GLubyte ***  l_Image0 = TabAlloc(l_Image0, m_Depth, p_Height, p_Width);
	GLubyte ***  l_Image1 = TabAlloc(l_Image1, m_Depth, p_Height, p_Width);
	GLubyte **** l_Image2 = TabAlloc(l_Image2, m_Depth, p_Height, p_Width,4);