error LNK2019

////////////////////////
//KTimer.h
#ifndef KTIMER_H
#define KTIMER_H
 
#pragma warning(disable: 4035)
typedef enum{Msec, Usec, Ns_100, Ns_10, Nsec} TimeUnit;
static int et[10];
inline unsigned _int64 GetCycleCount(void){
    _asm    rdtsc
}
 
class KTimer{
    _int64 t_start;
    _int64 t_stop;
    int overhead;
    //коэффициентные-делители
    double nCyclePer1nanoSec;
    double nCyclePer10nanoSec;
    double nCyclePer100nanoSec;
    double nCyclePer1microSec;
    double nCyclePer1milliSec;
    double divizor; //текущий делитель
public:
    KTimer(void){
        //калибровка overhead
        overhead = 0;
        int i;
        for(i=0;i<10;++i){
            t_start = GetCycleCount();
            et[i]=GetTick();
        }
        overhead = et[0];
        for(i=1;i<10; ++i)
            if(et[i]<overhead) overhead = et[i];
 
        //калибровка делителя
        timeBeginPeriod(i);
        Sleep(20);
 
        Start();
        Sleep(1000);
        t_stop=GetCycleCount()-t_start-overhead;
 
        nCyclePer1nanoSec   = t_stop/1000000000.;
        nCyclePer10nanoSec  = t_stop/100000000.;
        nCyclePer100nanoSec = t_stop/10000000.;
        nCyclePer1microSec  = t_stop/1000000.;
        nCyclePer1milliSec  = t_stop/1000.;
        timeEndPeriod(1);
        divizor = nCyclePer1milliSec;   //делитель по умолчанию
    }
 
    void SetUnit(TimeUnit unit){
        switch(unit){
            case Msec: divizor = nCyclePer1milliSec; break;
            case Usec: divizor = nCyclePer1microSec; break;
            case Nsec: divizor = nCyclePer1nanoSec; break;
            case Ns_10: divizor = nCyclePer10nanoSec; break;
            case Ns_100: divizor = nCyclePer100nanoSec; break;
        }
    }
 
    inline void Start(void){t_start = GetCycleCount();}
 
    inline int GetTick(void){
        return (int)(GetCycleCount()-t_start-overhead); 
    }
    inline double GetTime(void){
        t_start = GetCycleCount() - t_start - overhead;
        return t_stop/divizor;
    }
    inline int GetTickPerUsec(void){return (int)nCyclePer1microSec;}
    inline void uDelay(int uSec){
        int tElapsed = 0;
        SetUnit(Usec);
        Start();
 
        while(tElapsed<uSec)
            tElapsed - (int)GetTime();
    }
    int GetOverhead(){return overhead;}
};
 
#endif /*KTIMER_H*/
///////////////////////////
//Main.cpp
#include <windows.h>
#include <Mmsystem.h>
#include <fstream>
#include <iomanip>
using namespace std;
 
#include "KWnd.h"
#include "KTimer.h"
 
KTimer timer1;
KTimer timer2;
KTimer timer3;
 
#define N 5000000
int dTicks[N]; //число тактов счетчика TSC при профилировке нулевого участка
double grossWorkQuant[N];//кванты времени работы приложения (брутто)
ofstream flog;
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
//=================================
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
                   int nCmdShow)
{
    MSG msg;
    KWnd mainWnd(L"Тустирование класса KTimer", hInstance, nCmdShow, WndProc);
    while(GetMessage(&msg,NULL,0,0)){
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}
 
//==============================
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HDC hDC;
    PAINTSTRUCT ps;
    int i, No = 0;
    wchar_t text[200];
    double netWorkQuant; //квант времени работы приложения (нетто)
    double sleepQuant; //квант времени "отдыха" приложения
    double totalTime; //общее время выполнения цикла for
 
    switch(uMsg)
    {
    case WM_CREATE:
        flog.open("flog.txt");
        timer3.Start();
        timer2.Start();
 
        for(i=0;i<N;++i){
            timer1.Start(); //.... ноль инструкций на профилируемом участке
            dTicks[i] = timer1.GetTick();
            if(dTicks[i]>0){
                grossWorkQuant[i]=timer2.GetTime();
                timer2.Start();
            }
        }
        totalTime = timer3.GetTime();
        flog<<L"Отклонения измерений dTicks от ожидаемого значения 0\n";
        flog<<L"----------------------------------------------------\n";
        flog<<L"    No      i   dTicks  sleepQuant      workQuant   \n";
        flog<<L"                            (мс)          (мс)\n";
        flog<<L"----------------------------------------------------\n";
        flog.flags(ios::fixed);
        for(i=0;i<N;++i){
            if(dTicks[i]){
                No++;
                sleepQuant = (double)dTicks[i]/timer1.GetTickPerUsec()/1000.;
                netWorkQuant = grossWorkQuant[i] - sleepQuant;
                flog<<setw(8)<<No<<setw(10)<<i<<setw(10)
                    <<dTicks[i]<<setw(12)<<setprecision(5)<<sleepQuant
                    <<setw(10)<<setprecision(3)<<netWorkQuant<<endl;
            }
        }
        flog<<L"----------------------------------------------------\n";
        flog<<L"Общее время выполнения: "<<totalTime<<L" мс"<<endl;
        flog.close();
 
        InvalidateRect(hWnd,NULL, TRUE);
        break;
    case WM_PAINT:
        hDC = BeginPaint(hWnd, &ps);
        swprintf(text,L"overhead = %d, CPU speed: %d Mhz\0\n",
            timer1.GetOverhead(),timer1.GetTickPerUsec());
        TextOut(hDC,20,10,text,wcslen(text));
        EndPaint(hWnd,&ps);
        break;
 
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
 
    default:
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    return 0;
}
////////////////////////////////////

#pragma comment(lib, "<имя библиотеки>.lib")