Форум программистов, компьютерный форум CyberForum.ru

Error LNK2019: ссылка на неразрешенный внешний символ - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Односвязный список: В чём разница между struct и class? http://www.cyberforum.ru/cpp-beginners/thread1241053.html
После неудач работы с Vector, а так же отсутствия (Хотя, скорее всего, я просто плохо искал) хорошей русской документации по нему, решил запилить свой велосипед с самоваром и тёрками. Список состоит из шаблона класса "заголовка" и шаблона класса элемента. В шаблоне ссылка на первый элемент, размер списка и функции по работе со списком. Основу элемента списка составляет указатель на переменную...
C++ Создание и удаление объекта. Ошибка 134 в Linux Имеется следующий класс class BoardView { private: Board *brd; void Show(); public: http://www.cyberforum.ru/cpp-beginners/thread1241052.html
Как разделить результат, возвращаемый Multi curl? C++
1)Я вообще непонимаю зачем нужна функция static int writer(char *data, size_t size, size_t nmemb, string *buffer) как по мне делает какую-то ерунду. 2) На php курл реализован как-то лучше)) так как результат работы курла возвращает функция curl_exec аналог в с++ curl_easy_setopt который возвращает лишь статус(( ну да ладно вопрос в другом, ниже приведён код с использованием мультикурла,...
C++ Посчитать количество столбцов в строке, разделённых произвольным количеством белых знаков
Необходимо посчитать количество столбцов в строке, разделённых произвольным количеством белых знаков (кроме знака конца стоки). Также прошу подсказать, как реализовать такую конструкцию символов(буфер? поток?), из который можно было бы читать словами (>>), но при этом каждое следующие читание читало бы следующее слово.
C++ Ссылка на временный объект http://www.cyberforum.ru/cpp-beginners/thread1240939.html
Наткнулся тут в гугле на одну интересную тему. Как известно, данный код не соответствует стандарту, и не будет скомпилирован многими современными компиляторами: class A { }; void f( A & ) { }
C++ Что значит слово void изучаю функции,и наткнулся на: void DemonstrationFunction не могу понять,почему void,а не int.подскажите пожалуста Добавлено через 5 минут это случайно не "включить эту функцию в"? подробнее

Показать сообщение отдельно
влад10011
6 / 6 / 1
Регистрация: 19.07.2013
Сообщений: 54
11.08.2014, 14:02     Error LNK2019: ссылка на неразрешенный внешний символ
Здрасте,
Потребовалось вызвать dll из другой папки, пришлось переписывать импорт под динамический вызов, но тут полезли ероры.

myIDirect3DDevice9.obj : error LNK2001: неразрешенный внешний символ ""public: static int (__cdecl* TwBarFunc::TwWindowSize)(int,int)" (?TwWindowSize@TwBarFunc@@2P6AHHH@ZA)"

1>myIDirect3DDevice9.obj : error LNK2001: неразрешенный внешний символ ""public: static struct CTwBar * (__cdecl* TwBarFunc::TwNewBar)(char const *)" (?TwNewBar@TwBarFunc@@2P6APAUCTwBar@@PBD@ZA)"

1>myIDirect3DDevice9.obj : error LNK2001: неразрешенный внешний символ ""public: static int (__cdecl* TwBarFunc::TwInit)(enum ETwGraphAPI,void *)" (?TwInit@TwBarFunc@@2P6AHW4ETwGraphAPI@@PAX@ZA)"

1>proxydll.obj : error LNK2019: ссылка на неразрешенный внешний символ "public: static int (__cdecl* TwBarFunc::TwInit)(enum ETwGraphAPI,void *)" (?TwInit@TwBarFunc@@2P6AHW4ETwGraphAPI@@PAX@ZA) в функции _Direct3DCreate9@4

1>myIDirect3DDevice9.obj : error LNK2001: неразрешенный внешний символ ""public: static int (__cdecl* TwBarFunc::TwTerminate)(void)" (?TwTerminate@TwBarFunc@@2P6AHXZA)"

1>myIDirect3DDevice9.obj : error LNK2001: неразрешенный внешний символ ""public: static int (__cdecl* TwBarFunc::TwEventWin)(void *,unsigned int,unsigned int,int)" (?TwEventWin@TwBarFunc@@2P6AHPAXIIH@ZA)"

1>myIDirect3DDevice9.obj : error LNK2001: неразрешенный внешний символ ""public: static int (__cdecl* TwBarFunc::TwDraw)(void)" (?TwDraw@TwBarFunc@@2P6AHXZA)"

1>proxydll.obj : error LNK2001: неразрешенный внешний символ ""public: static struct HINSTANCE__ * TwBarFunc::handle" (?handle@TwBarFunc@@2PAUHINSTANCE__@@A)"


AntTweakBar.h:
C++
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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
// ----------------------------------------------------------------------------
//
//  @file       AntTweakBar.h
//
//  @brief      AntTweakBar is a light and intuitive graphical user interface 
//              that can be readily integrated into OpenGL and DirectX 
//              applications in order to interactively tweak parameters.
//
//  @author     Philippe Decaudin
//
//  @doc        [url]http://anttweakbar.sourceforge.net/doc[/url]
//
//  @license    This file is part of the AntTweakBar library.
//              AntTweakBar is a free software released under the zlib license.
//              For conditions of distribution and use, see License.txt
//
// ----------------------------------------------------------------------------
 
 
#if !defined TW_INCLUDED
#define TW_INCLUDED
 
#include <stddef.h>
 
#define TW_VERSION  116 // Version Mmm : M=Major mm=minor (e.g., 102 is version 1.02)
 
 
#ifdef  __cplusplus
#   if defined(_MSC_VER)
#       pragma warning(push)
#       pragma warning(disable: 4995 4530)
#       include <string>
#       pragma warning(pop)
#   else
#       include <string>
#   endif
    extern "C" {
#endif  // __cplusplus
 
 
// ----------------------------------------------------------------------------
//  OS specific definitions
// ----------------------------------------------------------------------------
 
#if (defined(_WIN32) || defined(_WIN64)) && !defined(TW_STATIC)
#   define TW_CALL          __stdcall
#   define TW_CDECL_CALL    __cdecl
#   define TW_EXPORT_API    __declspec(dllexport)
#   define TW_IMPORT_API    __declspec(dllimport)
#else
#   define TW_CALL
#   define TW_CDECL_CALL
#   define TW_EXPORT_API
#   define TW_IMPORT_API
#endif
 
#if defined TW_EXPORTS
#   define TW_API TW_EXPORT_API
#elif defined TW_STATIC
#   define TW_API
#   if defined(_MSC_VER) && !defined(TW_NO_LIB_PRAGMA)
#       ifdef _WIN64
#           pragma comment(lib, "AntTweakBarStatic64")
#       else
#           pragma comment(lib, "AntTweakBarStatic")
#       endif
#   endif
#else
#   define TW_API TW_IMPORT_API
#   if defined(_MSC_VER) && !defined(TW_NO_LIB_PRAGMA)
#       ifdef _WIN64
#           pragma comment(lib, "AntTweakBar64")
#       else
#           pragma comment(lib, "AntTweakBar")
#       endif
#   endif
#endif
 
        // ----------------------------------------------------------------------------
//  Var functions and definitions
// ----------------------------------------------------------------------------
 
typedef enum ETwType
{
    TW_TYPE_UNDEF   = 0,
#ifdef __cplusplus
    TW_TYPE_BOOLCPP = 1,
#endif // __cplusplus
    TW_TYPE_BOOL8   = 2,
    TW_TYPE_BOOL16,
    TW_TYPE_BOOL32,
    TW_TYPE_CHAR,
    TW_TYPE_INT8,
    TW_TYPE_UINT8,
    TW_TYPE_INT16,
    TW_TYPE_UINT16,
    TW_TYPE_INT32,
    TW_TYPE_UINT32,
    TW_TYPE_FLOAT,
    TW_TYPE_DOUBLE,
    TW_TYPE_COLOR32,    // 32 bits color. Order is RGBA if API is OpenGL or Direct3D10, and inversed if API is Direct3D9 (can be modified by defining 'colorOrder=...', see doc)
    TW_TYPE_COLOR3F,    // 3 floats color. Order is RGB.
    TW_TYPE_COLOR4F,    // 4 floats color. Order is RGBA.
    TW_TYPE_CDSTRING,   // Null-terminated C Dynamic String (pointer to an array of char dynamically allocated with malloc/realloc/strdup)
#ifdef __cplusplus
# if defined(_MSC_VER) && (_MSC_VER == 1600)
    TW_TYPE_STDSTRING = (0x2ffe0000+sizeof(std::string)),  // VS2010 C++ STL string (std::string)
# else
    TW_TYPE_STDSTRING = (0x2fff0000+sizeof(std::string)),  // C++ STL string (std::string)
# endif
#endif // __cplusplus
    TW_TYPE_QUAT4F = TW_TYPE_CDSTRING+2, // 4 floats encoding a quaternion {qx,qy,qz,qs}
    TW_TYPE_QUAT4D,     // 4 doubles encoding a quaternion {qx,qy,qz,qs}
    TW_TYPE_DIR3F,      // direction vector represented by 3 floats
    TW_TYPE_DIR3D       // direction vector represented by 3 doubles
} TwType;
#define TW_TYPE_CSSTRING(n) ((TwType)(0x30000000+((n)&0xfffffff))) // Null-terminated C Static String of size n (defined as char[n], with n<2^28)
 
typedef struct CTwEnumVal
{
    int           Value;
    const char *  Label;
} TwEnumVal;
typedef struct CTwStructMember
{
    const char *  Name;
    TwType        Type;
    size_t        Offset;
    const char *  DefString;
} TwStructMember;
typedef void (TW_CALL * TwSummaryCallback)(char *summaryString, size_t summaryMaxLength, const void *value, void *clientData);
 
 
// ----------------------------------------------------------------------------
//  Bar functions and definitions
// ----------------------------------------------------------------------------
typedef enum ETwParamValueType
{
    TW_PARAM_INT32,
    TW_PARAM_FLOAT,
    TW_PARAM_DOUBLE,
    TW_PARAM_CSTRING // Null-terminated array of char (ie, c-string)
} TwParamValueType;
 
typedef enum ETwGraphAPI
{
    TW_OPENGL           = 1,
    TW_DIRECT3D9        = 2,
    TW_DIRECT3D10       = 3,
    TW_DIRECT3D11       = 4,
    TW_OPENGL_CORE      = 5
} TwGraphAPI;
 
typedef struct CTwBar TwBar; // structure CTwBar is not exposed.
typedef void (TW_CALL * TwErrorHandler)(const char *errorMessage);
typedef void (TW_CALL * TwSetVarCallback)(const void *value, void *clientData);
typedef void (TW_CALL * TwGetVarCallback)(void *value, void *clientData);
typedef void (TW_CALL * TwButtonCallback)(void *clientData);
class TwBarFunc
{
public:
static HINSTANCE handle;
//TW_API TwBar *      TW_CALL TwNewBar(const char *barName);
static TwBar * (*TwNewBar) (const char *barName);
//TW_API int          TW_CALL TwDeleteBar(TwBar *bar);
static int (*TwDeleteBar) (TwBar *bar);
//TW_API int          TW_CALL TwDeleteAllBars();
static int (*TwDeleteAllBars) ();
//TW_API int          TW_CALL TwSetTopBar(const TwBar *bar);
static int (*TwSetTopBar) (TwBar *bar);
//TW_API TwBar *      TW_CALL TwGetTopBar();
static TwBar * (*TwGetTopBar) ();
//TW_API int          TW_CALL TwSetBottomBar(const TwBar *bar);
static int (*TwSetBottomBar) (const TwBar *bar);
//TW_API TwBar *      TW_CALL TwGetBottomBar();
static TwBar * (*TwGetBottomBar) ();
//TW_API const char * TW_CALL TwGetBarName(const TwBar *bar);
static char* (*TwGetBarName) (const TwBar *bar);
//TW_API int          TW_CALL TwGetBarCount();
static int (*TwGetBarCount) ();
//TW_API TwBar *      TW_CALL TwGetBarByIndex(int barIndex);
static TwBar* (*TwGetBarByIndex) (int barIndex);
//TW_API TwBar *      TW_CALL TwGetBarByName(const char *barName);
static TwBar* (*TwGetBarByName) (const TwBar *barName);
//TW_API int          TW_CALL TwRefreshBar(TwBar *bar);
//static int (*TwGetBarName) (TwBar *bar);
//TW_API int      TW_CALL TwKeyPressed(int key, int modifiers);
static int (*TwKeyPressed) (int key, int modifiers);
//TW_API int      TW_CALL TwKeyTest(int key, int modifiers);
static int (*TwKeyTest) (int key, int modifiers);
//TW_API int      TW_CALL TwAddVarRW(TwBar *bar, const char *name, TwType type, void *var, const char *def);
static int (*TwAddVarRW) (TwBar *bar, const char *name, TwType type, void *var, const char *def);
//TW_API int      TW_CALL TwAddVarRO(TwBar *bar, const char *name, TwType type, const void *var, const char *def);
static int (*TwAddVarRO) (TwBar *bar, const char *name, TwType type, const void *var, const char *def);
//TW_API int      TW_CALL TwAddVarCB(TwBar *bar, const char *name, TwType type, TwSetVarCallback setCallback, TwGetVarCallback getCallback, void *clientData, const char *def);
static int (*TwAddVarCB) (TwBar *bar, const char *name, TwType type, TwSetVarCallback setCallback, TwGetVarCallback getCallback, void *clientData, const char *def);
//TW_API int      TW_CALL TwAddButton(TwBar *bar, const char *name, TwButtonCallback callback, void *clientData, const char *def);
static int (*TwAddButton) (TwBar *bar, const char *name, TwButtonCallback callback, void *clientData, const char *def);
//TW_API int      TW_CALL TwAddSeparator(TwBar *bar, const char *name, const char *def);
static int (*TwAddSeparator) (TwBar *bar, const char *name, const char *def);
//TW_API int      TW_CALL TwRemoveVar(TwBar *bar, const char *name);
static int (*TwRemoveVar) (TwBar *bar, const char *name);
//TW_API int      TW_CALL TwRemoveAllVars(TwBar *bar);
static int (*TwRemoveAllVars) (TwBar *bar);
//TW_API int      TW_CALL TwDefine(const char *def);
static int (*TwDefine) (const char *def);
//TW_API TwType   TW_CALL TwDefineEnum(const char *name, const TwEnumVal *enumValues, unsigned int nbValues);
static TwType (*TwDefineEnum) (const char *name, const TwEnumVal *enumValues, unsigned int nbValues);
//TW_API TwType   TW_CALL TwDefineEnumFromString(const char *name, const char *enumString);
static TwType (*TwDefineEnumFromString) (const char *name, const char *enumString);
//TW_API TwType   TW_CALL TwDefineStruct(const char *name, const TwStructMember *structMembers, unsigned int nbMembers, size_t structSize, TwSummaryCallback summaryCallback, void *summaryClientData);
static TwType (*TwDefineStruct) (const char *name, const TwStructMember *structMembers, unsigned int nbMembers, size_t structSize, TwSummaryCallback summaryCallback, void *summaryClientData);
//TW_API int      TW_CALL TwGetParam(TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int outValueMaxCount, void *outValues);
static int (*TwGetParam) (TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int outValueMaxCount, void *outValues);
//TW_API int      TW_CALL TwSetParam(TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int inValueCount, const void *inValues);
static int (*TwSetParam) (TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int inValueCount, const void *inValues);
//TW_API int      TW_CALL TwInit(TwGraphAPI graphAPI, void *device);
static int (*TwInit) (TwGraphAPI graphAPI, void *device);
//TW_API int      TW_CALL TwTerminate();
static int (*TwTerminate) ();
//TW_API int      TW_CALL TwDraw();
static int (*TwDraw) ();
//TW_API int      TW_CALL TwWindowSize(int width, int height);
static int (*TwWindowSize) (int width, int height);
//TW_API int      TW_CALL TwSetCurrentWindow(int windowID); // multi-windows support
static int (*TwSetCurrentWindow) (int windowID);
//TW_API int      TW_CALL TwGetCurrentWindow();
static int (*TwGetCurrentWindow) ();
//TW_API int      TW_CALL TwWindowExists(int windowID);
static int (*TwWindowExists) (int windowID);
//TW_API int      TW_CALL TwMouseButton(TwMouseAction action, TwMouseButtonID button);
//int (*TwMouseButton) (TwMouseAction action, TwMouseButtonID butto);
//TW_API int      TW_CALL TwMouseMotion(int mouseX, int mouseY);
static int (*TwMouseMotion) (int mouseX, int mouseY);
//TW_API int      TW_CALL TwMouseWheel(int pos);
static int (*TwMouseWheel) (int pos);
//TW_API const char * TW_CALL TwGetLastError();
static const char* (*TwGetLastError) ();
//TW_API void     TW_CALL TwHandleErrors(TwErrorHandler errorHandler);
static void (*TwHandleErrors) (TwErrorHandler errorHandler);
#ifndef _W64    // Microsoft specific (detection of 64 bits portability issues)
#   define _W64
#endif  // _W64
#ifdef _WIN64
    //TW_API int  TW_CALL TwEventWin(void *wnd, unsigned int msg, unsigned __int64 _W64 wParam, __int64 _W64 lParam);
static int (*TwEventWin) (void *wnd, unsigned int msg, unsigned __int64 _W64 wParam, __int64 _W64 lParam);
#else
   // TW_API int  TW_CALL TwEventWin(void *wnd, unsigned int msg, unsigned int _W64 wParam, int _W64 lParam);
static int (*TwEventWin) (void *wnd, unsigned int msg, unsigned int _W64 wParam, int _W64 lParam);
#endif
}
/*
typedef void (TW_CALL * TwCopyCDStringToClient)(char **destinationClientStringPtr, const char *sourceString);
TW_API void     TW_CALL TwCopyCDStringToClientFunc(TwCopyCDStringToClient copyCDStringFunc);
TW_API void     TW_CALL TwCopyCDStringToLibrary(char **destinationLibraryStringPtr, const char *sourceClientString);
#ifdef __cplusplus
typedef void (TW_CALL * TwCopyStdStringToClient)(std::string& destinationClientString, const std::string& sourceString);
TW_API void     TW_CALL TwCopyStdStringToClientFunc(TwCopyStdStringToClient copyStdStringToClientFunc);
TW_API void     TW_CALL TwCopyStdStringToLibrary(std::string& destinationLibraryString, const std::string& sourceClientString);
#endif // __cplusplus*/
 
 
 
 
// ----------------------------------------------------------------------------
//  Management functions and definitions
// ----------------------------------------------------------------------------
 
 
#define    TW_MOUSE_RELEASED = 0;
#define    TW_MOUSE_PRESSED  = 1;
 
 
#define     TW_MOUSE_LEFT       = 1;   // same code as SDL_BUTTON_LEFT
#define     TW_MOUSE_MIDDLE     = 2;    // same code as SDL_BUTTON_MIDDLE
#define     TW_MOUSE_RIGHT      = 3;     // same code as SDL_BUTTON_RIGHT
 
#if defined(_UNIX)
    TW_API int TW_CDECL_CALL TwEventX11(void *xevent);
#endif
 
#define TW_COMPILE_TIME_ASSERT(name, x) typedef int TW_DUMMY_ ## name[(x) * 2 - 1]
 
//TW_COMPILE_TIME_ASSERT(TW_CHAR,    sizeof(char)    == 1);
//TW_COMPILE_TIME_ASSERT(TW_SHORT,   sizeof(short)   == 2);
//TW_COMPILE_TIME_ASSERT(TW_INT,     sizeof(int)     == 4);
//TW_COMPILE_TIME_ASSERT(TW_FLOAT,   sizeof(float)   == 4);
//TW_COMPILE_TIME_ASSERT(TW_DOUBLE,  sizeof(double)  == 8);
 
// Check pointer size on Windows
#if !defined(_WIN64) && defined(_WIN32)
    // If the following assert failed, the platform is not 32-bit and _WIN64 is not defined.
    // When targetting 64-bit Windows platform, _WIN64 must be defined.
//    TW_COMPILE_TIME_ASSERT(TW_PTR32, sizeof(void*) == 4);
#elif defined(_WIN64)
    // If the following assert failed, _WIN64 is defined but the targeted platform is not 64-bit.
    TW_COMPILE_TIME_ASSERT(TW_PTR64, sizeof(void*) == 8);
#endif
 
//  ---------------------------------------------------------------------------
 
 
#ifdef  __cplusplus
    ;}   // extern "C"
#endif  // __cplusplus
 
 
#endif  // !defined TW_INCLUDED
Вызов функций из myIDirect3DDevice9.cpp:
C++
1
2
3
4
     TwBarFunc::TwInit(TW_DIRECT3D9, m_pIDirect3DDevice9);
     MyTwBar = TwBarFunc::TwNewBar("TweakBar");
     TwBarFunc::TwWindowSize(600, 600);
//       TwBarFunc::TwSetTopBar(MyTwBar);
В чём проблема?
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
Текущее время: 16:08. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru