error LNK2019: unresolved external symbol errors with code that I'm using

Question

Here is the error :

>------ Build started: Project: Someapp, Configuration: Debug Win32 ------
1>Someapp.cpp
1>Someapp.obj : error LNK2019: unresolved external symbol "public: __thiscall CSkin::CSkin(int,int)" (??0CSkin@@QAE@HH@Z) referenced in function _wWinMain@16
1>Someapp.obj : error LNK2019: unresolved external symbol "public: virtual __thiscall CSkin::~CSkin(void)" (??1CSkin@@UAE@XZ) referenced in function _wWinMain@16
1>Someapp.obj : error LNK2019: unresolved external symbol "public: int __thiscall CSkin::Width(void)" (?Width@CSkin@@QAEHXZ) referenced in function _wWinMain@16
1>Someapp.obj : error LNK2019: unresolved external symbol "public: int __thiscall CSkin::Height(void)" (?Height@CSkin@@QAEHXZ) referenced in function _wWinMain@16
1>Someapp.obj : error LNK2019: unresolved external symbol "public: struct HRGN__ * __thiscall CSkin::HRGN(void)" (?HRGN@CSkin@@QAEPAUHRGN__@@XZ) referenced in function _wWinMain@16
1>C:\Users\Rubel\source\repos\Someapp\Debug\Someapp.exe : fatal error LNK1120: 5 unresolved externals
1>Done building project "Someapp.vcxproj" -- FAILED.
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

This skin class code( I got from https://www.flipcode.com/archives/Win32_Window_Skinning.shtml) works I tested but for some reason it's complaining about unresolved external symbol errors. Please, help I don't know what the problem is.

Code of skin class skin.h

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
//
// WINDOWS SKINNING TUTORIAL - by Vander Nunes - virtware.net
// This is the source-code that shows what is discussed in the tutorial.
// The code is simplified for the sake of clarity, but all the needed
// features for handling skinned windows is present. Please read
// the article for more information.
//
// skin.h     : CSkin class declaration
// 28/02/2002 : initial release.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-


#ifndef _SKIN_H_

  #define _SKIN_H_

  #include <windows.h>


  // --------------------------------------------------------------------------
  // The CSkin class will load the skin from a resource
  // and subclass the associated window, so that the
  // WM_PAINT message will be redirected to the provided
  // window procedure. All the skin handling will be automatized.
  // --------------------------------------------------------------------------

  class CSkin
  {

    // --------------------------------------------------------------------------
    // the skin window procedure, where the class
    // will handle WM_PAINT and WM_LBUTTONDOWN automatically.
    // --------------------------------------------------------------------------
    friend LRESULT CALLBACK SkinWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam);

    private:

      // the associated window handle
      HWND      m_hWnd;

      // the old window procedure
      WNDPROC   m_OldWndProc;

      // skin region
      HRGN      m_rgnSkin;

      // the internal skin device context handle
      HDC       m_dcSkin;

      // bitmap and old bitmap from the device context
      HBITMAP   m_hBmp, m_hOldBmp;

      // skin dimensions
      int       m_iWidth, m_iHeight;

      // on|off toggle
      bool      m_bEnabled;

      // tell the class if it has a window subclassed.
      bool      m_bHooked;

      // skin retrieval helper
      bool      GetSkinData(int iSkinRegion, int iSkinBitmap);

    public:

      // ----------------------------------------------------------------------------
      // constructor 1 - use it when you have not already created the app window.
      // this one will not subclass automatically, you must call Hook() to subclass.
      // will throw an exception if unable to initialize skin from resource.
      // ----------------------------------------------------------------------------

      CSkin(int iSkinRegion, int iSkinBitmap);

      // ----------------------------------------------------------------------------
      // constructor 2 - use it when you have already created the app window.
      // this one will subclass the window automatically.
      // will throw an exception if unable to initialize skin from resource.
      // ----------------------------------------------------------------------------

      CSkin(HWND hWnd, int iSkinRegion, int iSkinBitmap);

      // ----------------------------------------------------------------------------
      // destructor - just call the destroyer
      // ----------------------------------------------------------------------------

      virtual ~CSkin();

      // ----------------------------------------------------------------------------
      // destroy skin resources and free allocated resources
      // ----------------------------------------------------------------------------

      void Destroy();

      // ----------------------------------------------------------------------------
      // subclass a window.
      // ----------------------------------------------------------------------------

      bool    Hook(HWND hWnd);

      // ----------------------------------------------------------------------------
      // unsubclass the subclassed window.
      // ----------------------------------------------------------------------------

      bool    UnHook();

      // ----------------------------------------------------------------------------
      // tell us if we have a window subclassed.
      // ----------------------------------------------------------------------------

      bool    Hooked();

      // ----------------------------------------------------------------------------
      // toggle skin on/off.
      // ----------------------------------------------------------------------------

      bool    Enable(bool bEnable);

      // ----------------------------------------------------------------------------
      // tell if the skinning is enabled
      // ----------------------------------------------------------------------------

      bool    Enabled();

      // ----------------------------------------------------------------------------
      // return the skin bitmap width.
      // ----------------------------------------------------------------------------

      int     Width();

      // ----------------------------------------------------------------------------
      // return the skin bitmap height.
      // ----------------------------------------------------------------------------

      int     Height();

      // ----------------------------------------------------------------------------
      // return the skin device context.
      // ----------------------------------------------------------------------------

      HDC     HDC();

      // ----------------------------------------------------------------------------
      // return the skin handle  to the region.
      // ----------------------------------------------------------------------------

      HRGN HRGN();
  };

#endif

skin.cpp:

// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
//
// WINDOWS SKINNING TUTORIAL - by Vander Nunes - virtware.net
// This is the source-code that shows what is discussed in the tutorial.
// The code is simplified for the sake of clarity, but all the needed
// features for handling skinned windows is present. Please read
// the article for more information.
//
// skin.cpp   : CSkin class implementation
// 28/02/2002 : initial release.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-


#include "skin.h"



// ----------------------------------------------------------------------------
// constructor 1 - use it when you have not already created the app window.
// this one will not subclass automatically, you must call Hook() and Enable()
// to subclass the app window and enable the skin respectively.
// will throw an exception if unable to initialize skin from resource.
// ----------------------------------------------------------------------------

CSkin::CSkin(int iSkinRegion, int iSkinBitmap)
{
  // default starting values
  m_bHooked = false;
  m_OldWndProc = NULL;

  // try to retrieve the skin data from resource.
  if ( !GetSkinData(iSkinRegion, iSkinBitmap) )
    throw ("Unable to retrieve the skin.");
}



// ----------------------------------------------------------------------------
// constructor 2 - use it when you have already created the app window.
// this one will subclass the window and enable the skin automatically.
// will throw an exception if unable to initialize skin from resource.
// ----------------------------------------------------------------------------
CSkin::CSkin(HWND hWnd, int iSkinRegion, int iSkinBitmap)
{
  // default starting values
  m_bHooked = false;
  m_OldWndProc = NULL;

  // initialize
  CSkin(iSkinRegion, iSkinBitmap);

  // subclass
  Hook(hWnd);

  // enable
  Enable(true);
}



// ----------------------------------------------------------------------------
// destructor - just call the destroyer
// ----------------------------------------------------------------------------
CSkin::~CSkin()
{
  Destroy();
}



// ----------------------------------------------------------------------------
// destroy skin resources and free allocated resources
// ----------------------------------------------------------------------------
void CSkin::Destroy()
{
  // unhook the window
  UnHook();

  // free bitmaps and device context
  if (m_dcSkin) { SelectObject(m_dcSkin, m_hOldBmp); DeleteDC(m_dcSkin); m_dcSkin = NULL; }
  if (m_hBmp) { DeleteObject(m_hBmp); m_hBmp = NULL; }

  // free skin region
  if (m_rgnSkin) { DeleteObject(m_rgnSkin); m_rgnSkin = NULL; }
}



// ----------------------------------------------------------------------------
// toggle skin on/off - must be Hooked() before attempting to enable skin.
// ----------------------------------------------------------------------------
bool CSkin::Enable(bool bEnable)
{
  // refuse to enable if there is no window subclassed yet.
  if (!Hooked()) return false;

  // toggle
  m_bEnabled = bEnable;

  // force window repainting
  InvalidateRect(m_hWnd, NULL, TRUE);

  return true;
}



// ----------------------------------------------------------------------------
// tell if the skinning is enabled
// ----------------------------------------------------------------------------
bool CSkin::Enabled()
{
  return m_bEnabled;
}



// ----------------------------------------------------------------------------
// hook a window
// ----------------------------------------------------------------------------
bool CSkin::Hook(HWND hWnd)
{
  // unsubclass any other window
  if (Hooked()) UnHook();

  // this will be our new subclassed window
  m_hWnd = hWnd;

  // set the skin region to the window
  SetWindowRgn(m_hWnd, m_rgnSkin, true);

  // subclass the window procedure
  m_OldWndProc = (WNDPROC)SetWindowLong(m_hWnd, GWL_WNDPROC, (LONG)SkinWndProc);

  // store a pointer to our class instance inside the window procedure.
  if (!SetProp(m_hWnd, "skin", (void*)this))
  {
    // if we fail to do so, we just can't activate the skin.
    UnHook();
    return false;
  }

  // update flag
  m_bHooked = ( m_OldWndProc ? true : false );

  // force window repainting
  InvalidateRect(m_hWnd, NULL, TRUE);

  // successful return if we're hooked.
  return m_bHooked;
}



// ----------------------------------------------------------------------------
// unhook the window
// ----------------------------------------------------------------------------
bool CSkin::UnHook()
{
  // just to be safe we'll check this
  WNDPROC OurWnd;

  // cannot unsubclass if there is no window subclassed
  // returns true anyways.
  if (!Hooked()) return true;

  // remove the skin region from the window
  SetWindowRgn(m_hWnd, NULL, true);

  // unsubclass the window procedure
  OurWnd = (WNDPROC)SetWindowLong(m_hWnd, GWL_WNDPROC, (LONG)m_OldWndProc);

  // remove the pointer to our class instance, but if we fail we don't care.
  RemoveProp(m_hWnd, "skin");

  // update flag - if we can't get our window procedure address again,
  // we failed to unhook the window.
  m_bHooked = ( OurWnd ? false : true );

  // force window repainting
  InvalidateRect(m_hWnd, NULL, TRUE);

  // successful return if we're unhooked.
  return !m_bHooked;
}



// ----------------------------------------------------------------------------
// tell us if there is a window subclassed
// ----------------------------------------------------------------------------
bool CSkin::Hooked()
{
  return m_bHooked;
}



// ----------------------------------------------------------------------------
// return the skin bitmap width
// ----------------------------------------------------------------------------
int CSkin::Width()
{
  return m_iWidth;
}



// ----------------------------------------------------------------------------
// return the skin bitmap height
// ----------------------------------------------------------------------------
int CSkin::Height()
{
  return m_iHeight;
}



// ----------------------------------------------------------------------------
// return the skin device context
// ----------------------------------------------------------------------------
HDC CSkin::HDC()
{
  return m_dcSkin;
}

// ----------------------------------------------------------------------------
// return the skin handle to the region
// ----------------------------------------------------------------------------

HRGN CSkin::HRGN()
{
    return m_rgnSkin;
}

// ----------------------------------------------------------------------------
// skin retrieval helper
// ----------------------------------------------------------------------------
bool CSkin::GetSkinData(int iSkinRegion, int iSkinBitmap)
{
  // get app instance handle
  HINSTANCE hInstance = GetModuleHandle(NULL);

  // -------------------------------------------------
  // retrieve the skin bitmap from resource.
  // -------------------------------------------------

  m_hBmp = LoadBitmap(hInstance, MAKEINTRESOURCE(iSkinBitmap));
  if (!m_hBmp) return false;

  // get skin info
  BITMAP bmp;
  GetObject(m_hBmp, sizeof(bmp), &bmp);

  // get skin dimensions
  m_iWidth = bmp.bmWidth;
  m_iHeight = bmp.bmHeight;


  // -------------------------------------------------
  // then, we retrieve the skin region from resource.
  // -------------------------------------------------

  // ask resource for our skin.
  HRSRC hrSkin = FindResource(hInstance, MAKEINTRESOURCE(iSkinRegion),"BINARY");
  if (!hrSkin) return false;

  // this is standard "BINARY" retrieval.
  LPRGNDATA pSkinData = (LPRGNDATA)LoadResource(hInstance, hrSkin);
  if (!pSkinData) return false;

  // create the region using the binary data.
  m_rgnSkin = ExtCreateRegion(NULL, SizeofResource(NULL,hrSkin), pSkinData);

  // free the allocated resource
  FreeResource(pSkinData);

  // check if we have the skin at hand.
  if (!m_rgnSkin) return false;


  // -------------------------------------------------
  // well, things are looking good...
  // as a quick providence, just create and keep
  // a device context for our later blittings.
  // -------------------------------------------------

  // create a context compatible with the user desktop
  m_dcSkin = CreateCompatibleDC(0);
  if (!m_dcSkin) return false;

  // select our bitmap
  m_hOldBmp = (HBITMAP)SelectObject(m_dcSkin, m_hBmp);


  // -------------------------------------------------
  // done
  // -------------------------------------------------
  return true;
}



// ------------------------------------------------------------------------
// Default skin window procedure.
// Here the class will handle WM_PAINT and WM_LBUTTONDOWN, originally sent
// to the application window, but now subclassed. Any other messages will
// just pass through the procedure and reach the original app procedure.
// ------------------------------------------------------------------------
LRESULT CALLBACK SkinWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
  // we will need a pointer to the associated class instance
  // (it was stored in the window before, remember?)
  CSkin *pSkin = (CSkin*)GetProp(hWnd, "skin");

  // to handle WM_PAINT
    PAINTSTRUCT ps;

  // if we fail to get our class instance, we can't handle anything.
  if (!pSkin) return DefWindowProc(hWnd,uMessage,wParam,lParam);

  switch(uMessage)
  {

    case WM_PAINT:
    {
      // ---------------------------------------------------------
      // here we just need to blit our skin
      // directly to the device context
      // passed by the painting message.
      // ---------------------------------------------------------
      BeginPaint(hWnd,&ps);

      // blit the skin
      BitBlt(ps.hdc,0,0,pSkin->Width(),pSkin->Height(),pSkin->HDC(),0,0,SRCCOPY);

      EndPaint(hWnd,&ps);
      break;
    }

    case WM_LBUTTONDOWN:
    {
      // ---------------------------------------------------------
      // this is a common trick for easy dragging of the window.
      // this message fools windows telling that the user is
      // actually dragging the application caption bar.
      // ---------------------------------------------------------
      SendMessage(hWnd, WM_NCLBUTTONDOWN, HTCAPTION,NULL);
      break;
    }

  }

  // ---------------------------------------------------------
  // call the default window procedure to keep things going.
  // ---------------------------------------------------------
  return CallWindowProc(pSkin->m_OldWndProc, hWnd, uMessage, wParam, lParam);
}

Someapp.h

#pragma once

#include "resource.h"
#include <Windows.h>

HWND hWnd=NULL;

// window creation helper
bool MakeWindow(int iWidth, int iHeight);

Someapp.cpp

// Someapp.cpp : Defines the entry point for the application.
//

#include "framework.h"
#include "Someapp.h"
#include "../SkinClass/skin.h"
#include <windows.h>
#include <gdiplus.h>
using namespace Gdiplus;
#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name

// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: Place code here.
    GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_SOMEAPP, szWindowClass, MAX_LOADSTRING);
    /*MyRegisterClass(hInstance);*/

    // Perform application initialization:
    /*if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
    */
    CSkin skina (IDR_SKINREGION, ID_SKIN);
    MakeWindow(skina.Width(),skina.Height());
    Graphics gra (hWnd, false);
    gra.SetClip(skina.HRGN(), CombineModeReplace);
    Image image(L"skin.bmp");
    gra.DrawImage(&image,1,1);
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SOMEAPP));

    MSG msg;
    UpdateWindow(hWnd);
    // Main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    GdiplusShutdown(gdiplusToken);
    return (int) msg.wParam;
}



//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_SOMEAPP));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_SOMEAPP);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handle in our global variable

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE: Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // Parse the menu selections:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: Add any drawing code that uses hdc here...
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

bool MakeWindow(int iWidth, int iHeight)
{
    // our window class
    WNDCLASS wndWc;

    // ---------------------------------------------------------
    // fill window class members
    // ---------------------------------------------------------
    wndWc.style = CS_OWNDC;
    wndWc.lpfnWndProc = (WNDPROC)WndProc;
    wndWc.cbClsExtra = 0;
    wndWc.cbWndExtra = 0;
    wndWc.hInstance = GetModuleHandle(NULL);
    wndWc.hIcon = NULL;
    wndWc.hCursor = LoadCursor(0, IDC_ARROW);
    wndWc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wndWc.lpszMenuName = NULL;
    wndWc.lpszClassName = "w32skin";

    // register class
    RegisterClass(&wndWc);
    // ---------------------------------------------------------

    // get actual screen resolution
    int iSw = (WORD)GetSystemMetrics(SM_CXSCREEN);       // width
    int iSh = (WORD)GetSystemMetrics(SM_CYSCREEN);       // height

    // make a rectangle on the center of the screen
    RECT rc = { (iSw - iWidth) / 2, (iSh - iHeight) / 2, iWidth, iHeight };

    // create the window.
    // note the WS_POPUP flag, no caption, no borders, no nothing.
    hWnd = CreateWindow("w32skin", "w32skin",
        WS_POPUP,
        rc.left, rc.top, iWidth, iHeight,
        NULL, NULL, GetModuleHandle(NULL), NULL);

    // return result
    return (hWnd ? true : false);
}