Visual studio ошибка lnk2019

I get this error, but I don’t know how to fix it.

I’m using Visual Studio 2013. I made the solution name MyProjectTest
This is the structure of my test solution:

—function.h

#ifndef MY_FUNCTION_H
#define MY_FUNCTION_H

int multiple(int x, int y);
#endif

-function.cpp

#include "function.h"

int multiple(int x, int y){
    return x*y;
}

—main.cpp

#include <iostream>
#include <cstdlib>
#include "function.h"

using namespace std;

int main(){
    int a, b;
    cin >> a >> b;
    cout << multiple(a, b) << endl;

    system("pause");
    return 0;
}

I’m a beginner; this is a simple program and it runs without error.
I read on the Internet and became interested in the unit test, so I created a test project:

Menu File → New → Project… → Installed → Templates → Visual C++ → Test → Native Unit Test Project →

Name: UnitTest1
Solution: Add to solution

Then the location auto-switched to the path of the current open solution.

This is the folder structure of the solution:

I only edited file unittest1.cpp:

#include "stdafx.h"
#include "CppUnitTest.h"
#include "../MyProjectTest/function.h"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace UnitTest1
{
    TEST_CLASS(UnitTest1)
    {
    public:

        TEST_METHOD(TestEqual)
        {
            Assert::AreEqual(multiple(2, 3), 6);
            // TODO: Your test code here
        }

    };
}

But I get:

error LNK2019: unresolved external symbol.

I know that the implementation of function multiple is missing.
I tried to delete the function.cpp file and I replaced the declaration with the definition, and it ran. But writing both declaration and definition in the same file is not recommended.

How can I fix this error without doing that? Should I replace it with #include "../MyProjectTest/function.cpp" in file unittest.cpp?

Because of the comment below, I’ve rewritten what I had before.

The problem that the linker is complaining about is that you’ve declared your member functions in Poker, but haven’t defined them. How is this? For starters, you’re creating a new class and defining separate member functions in it.

Your header file Poker class exists in the PokerGame namespace and your cpp file Poker class exists in the global namespace. To fix that issue, put them in the same namespace:

//cpp file
namespace PokerGame {
    class Poker {
        ...
    };
}

Now that they’re in the same namespace, you have another issue. You’re defining your member functions inside the class body, but not the first one. The definitions simply can’t go in the body of a class named the same way. Get rid of the whole class in the cpp file:

//cpp file
namespace PokerGame {
    Poker::Poker() {
        deck = Deck(); //consider a member initializer instead
    }

    //other definitions
}

One last thing: you put the private section of your class in the wrong spot. It was in that cpp file class that we just removed. It belongs with the other parts of your class:

//header file
namespace PokerGame {
    class Poker {
    public:
        //public stuff

    private: 
        Deck deck; //moved from cpp file
   };
}

Вот текст программы:

#include «StdAfx.h»
#include <iostream>
#include <vector>
#include <tchar.h>
#include <windows.h>
#include <process.h>
#include <assert.h>

// Grammar Engine API
// API грамматической машины
#include <D:\Program Files (x86)\SynonymizerSDK\include\lem\solarix\synonymizer_engine.h>
#include <D:\Program Files (x86)\SynonymizerSDK\include\lem\solarix\_sg_api.h>

using namespace std;

void TestRussian( HFAIND hEngine );
void TestEnglish( HFAIND hEngine );

const int DEF_TIMEOUT = 1000000; // 1000 секунд

static bool exists( const TCHAR *path )
{ return GetFileAttributes(path)!=(DWORD)INVALID_FILE_ATTRIBUTES; }

// **************************************************************
// Вспомогательная процедура — вывод UNICODE текста на консоль
// **************************************************************
static void wide( const wchar_t *ustr )
{
 if( ustr==NULL || *ustr==0 )
  return;

 const int l = wcslen(ustr);
 char *abuffer = new char[l+1];
 memset( abuffer, 0, l+1 );
 WideCharToMultiByte( CP_OEMCP, 0, ustr, l+1, abuffer, l+1, NULL, NULL );
 printf( «%s», abuffer );
 delete[] abuffer;

 return;
}

static HFAIND hEngine = NULL;
static HGREN_PHRASOMAT hFG = NULL;

#if defined TEST_THREADS
unsigned int __stdcall FG_Thread(void*)
{
 const wchar_t *words[] = {
                           L»ПОЛУНОЧИ»,
                           NULL

                          };  

 std::vector<int> ies;
 int j=0;
 while( words[j]!=NULL )
  {
   int ie = sol_FindEntry( hEngine, words[j++], NOUN_ru, -1 );
   if( ie!=-1 )
    ies.push_back(ie);  
  }

 sol_SetWordsForPhrase( hFG, ies.size(), &*ies.begin(), true );

 // Сгенерируем парочку предложений с измененным набором слов
 for( int i=0; i<1000; i++ )
  {
   wchar_t *phrase = sol_GeneratePhrase(hFG,0xffffffff,FG_DEBUG);
   printf( «#%5d—>», i );
   wide(phrase);
   printf( «\n» );
   sol_DeleteGeneratedPhrase(phrase);
  }

 return 0;
}
#endif

static void Imitate( const wchar_t *src_filename, int language )
{
 if( GetFileAttributesW(src_filename)==(DWORD)-1 )
  {
   return;
  }

 // генерация квазислучайного текста на основе сведений о матрице переходов,
 // создаваемой по исходному тексту.
 // Сначала строим матрицу.
 int rc1 = sol_BuildKnowledgeBase2( hFG, L»e:\\MVoice\\lem\\scripts\\rewriter\\путеводитель.txt», 3, 0 );
 // Теперь генерация текста.
 for( int i=0; i<20; i++ )
  {
   wchar_t *phrase = sol_GeneratePhrase(
                                        hFG,
                                        FG_GENERATOR_USES_CHAINS,
                                        FG_NO_DEBUG
                                       );

   printf( «#%2d «, i );
   wide(phrase);
   printf( «\n» );

   sol_DeleteGeneratedPhrase(phrase);
  }

 // ——————————————————————
 // Имитация стиля — строим базу знаний из текста и затем генерируем
 // случайный текст на основе информации.
 // ——————————————————————
 wchar_t tmp_db_folder[MAX_PATH];
 swprintf( tmp_db_folder, L»%s\\TestKnowledgeBase», _wgetenv(L»TMP») );
 CreateDirectoryW( tmp_db_folder, NULL );

 // удалим старое содержимое, если оно было.
 wchar_t cmdx[MAX_PATH*2];
 swprintf( cmdx, L»del /q %s\\*.*», tmp_db_folder );
 _wsystem( cmdx );

 int rc = sol_BuildKnowledgeBase( hEngine, src_filename, tmp_db_folder, language, 0 );
 rc = sol_LoadKnowledgeBase( hFG, tmp_db_folder );

 for( int i=0; i<20; i++ )
  {
   wchar_t *phrase = sol_GeneratePhrase(
                                        hFG,
                                        FG_LOGICS | FG_GERUND1
| FG_GERUND2 | FG_COMSENT |
                                        FG_USE_LEX_WHEN_EXHAUSTED
|
                                        FG_DONT_REMOVE_USED |
                                        FG_GENERATOR_USES_NGRAMS,
                                        FG_DEBUG
                                       );

   // рассчитываем оценку достоверности фразы по стистическому критерию
   int unmatched_2_ngrams=0, n2=0, n3=0;
   int rc = sol_MatchNGrams( hEngine, phrase, &unmatched_2_ngrams, &n2, &n3 );
   float r=0.0F;
   if( (n2+unmatched_2_ngrams)!=0 )
    r = float(n2+n3)/float(n2+n3+unmatched_2_ngrams);

   printf( «#%2d «, i );
   wide(phrase);
   printf( » [[%g]]\n», r );
   sol_DeleteGeneratedPhrase(phrase);
  }

 return;
}

int main(void)
{
 // Грузим морфологию, синтаксис и другие модули.
 // Словарь должен быть уже подготовлен и находится в текущем каталоге или одном
 // из стандартных для SDK/Integra каталогов. Для подготовки словаря можно запустить
 // один из скриптов в \sdk\scripts\dictionary.
 cout << «Loading grammar engine…\n»;

 bool dict_ok=false;

 const TCHAR * paths[] = {
                          _T(«..\\..\\..\\..\\..\\..\\bin-windows\\dictionary.xml»),
                          _T(«..\\..\\..\\..\\..\\..\\dictionary.xml»),
                          _T(«dictionary.xml»),
                          NULL

                         };

 int ipath=0;
 while( paths[ipath]!=NULL && dict_ok==false )
  {
   if( exists(paths[ipath]) )
    {
     hEngine = sol_CreateGrammarEngine(paths[ipath++]);
     if( hEngine!=NULL )
      dict_ok=true;
    }
  }

 if( dict_ok )
  {
   int nentry = sol_CountEntries(hEngine);
   cout << «Engine is loaded OK\n»;
  }
 else
  {
   cout << «Error loading dictionary file ‘diction.xml\n»
           «You have to download the latest dictionary build\n»
           «from http://sourceforge.net/project/solarix»;
   return -1;
  }

 TestRussian(hEngine);
 //TestEnglish(hEngine);

 // Free allocated resources, delete the engine instance.
 sol_DeleteGrammarEngine(hEngine);

 cout << «All done.\n»;

 return 0;
}

static void TestGenerator(void);
static void TestSynonymizer(void);
static void TestParaphraser(void);
static void TestImitator(void);

void TestRussian( HFAIND hEngine )
{
 if( sol_FindEntry( hEngine, L»МАМА», /*Solarix::API::*/NOUN_ru, /*Solarix::API::*/RUSSIAN_LANGUAGE )==-1 )
  {
   cout << «Russian lexicon is missing.\n»;
   return;
  }

 TestGenerator();
 TestSynonymizer();
// TestParaphraser();
 TestImitator();

 return;
}

void TestEnglish( HFAIND hEngine )
{
 // Проверяем наличие английского лексикона.
 if( sol_FindEntry( hEngine, L»MOTHER», /*Solarix::API::*/NOUN_en, /*Solarix::API::*/ENGLISH_LANGUAGE )==-1 )
  {
   cout << «English lexicon is missing.\n»;
   return;
  }

 // Создаем генератор предложений для английского языка
 hFG = sol_CreatePhraseGenerator(hEngine,ENGLISH_LANGUAGE);

 wchar_t buffer[10001];
 memset( buffer, 0, sizeof(buffer) );

 bool is_premium = sol_GetVersion( hEngine, NULL, NULL, NULL);

 if( is_premium )
  {
   // Проверяем сложные синонимы (доступно в версии Premium)

   const wchar_t *orgs[] =
   {
    L»I decided to stay»,
    L»I’ve decided to stay»,
    L»We decide to stay»,
    L»He decides to stay»,
    L»I am deciding to stay»,
    L»You must decide to stay»,
    NULL
   };

   int iorg=0;
   while( orgs[iorg]!=NULL )
    {
     const wchar_t *s = orgs[iorg];

     int rc2 = sol_Paraphrase(
                              hFG,
                              FG_SYNONYMIZE | FG_SYNONYMIZER_MULTIWORD,
                              FG_PEDANTIC_ANALYSIS,   
                              FG_NO_NGRAMS,
                              0,

                              FG_DEBUG,
                              FG_YIELD_PLAIN_TEXT,
                              5,
                              s,
                              buffer,
                              10000,
                              DEF_TIMEOUT
                             );

     printf( «%s —> «, s );   
     wide(buffer);
     printf( «\n» );
     iorg++;
    }
  }
// int rc = sol_Paraphrase( hFG, FG_SYNONYMIZE_OTHERS | FG_SYNONYMIZER_USES_NGRAMS | FG_DEBUG, 5, L»The cat catches the mouse.», buffer, 10000 );

 const wchar_t *orgs[] =
 {
  L»I decided to stay»,
  L»The mouse will be surrendering»,
  L»The mouse is surrendering»,
  L»The jolly mouse», // тут ошибка!
  L»The funny mouse»,
  L»The mouse surrendered»,
  L»is asked»,
  L»will be asked»,
  L»will be asking»,
  L»will be surrendering»,
  L»is surrendering»,
  L»The mouse surrenders»,
  L»The mouse will surrender»,
  L»Kitties»,
  L»Funny job»,
  L»Merry christmas»,
  L»Tremendous danger»,
  L»Huge disaster»,
  L»The mouse gives up.»,
  L»The kitty surrendered.»,
  L»White cat silently sleeps.»,
  L»Black cat catches the moise.»,
  NULL
 };

 int iorg=0;
 while( orgs[iorg]!=NULL )
  {
   const wchar_t *s = orgs[iorg];
   int rc = sol_Paraphrase(
                           hFG,
                           FG_SYNONYMIZE | FG_SYNONYMIZER_MULTIWORD,
                           FG_PEDANTIC_ANALYSIS,   
                           FG_NO_NGRAMS,
                           0,

                           FG_DEBUG,
                           FG_YIELD_PLAIN_TEXT,
                           5,
                           s,
                           buffer,
                           10000,
                           DEF_TIMEOUT
                          );

   if( wcscmp( s, buffer )==0 )
    {
     printf( «Error, no synonymization occured for phrase: %s\n», s );
    }
   else
    {
     printf( «#%d «, iorg );
     wide(s);
     printf( » —> » );
     wide(buffer);
     printf( «\n» );
    }

   iorg++;
  }

 // sol_RandomizePhraseGenerator(hFG);

 // Тестируем нефильтрованную по лексике генерацию
 for( int i=0; i<30; i++ )
  {
   wchar_t *phrase = sol_GeneratePhrase(hFG,0,FG_DEBUG);

   if( wcsstr( phrase, L»(—» )!=NULL || wcsstr( phrase, L»???» )!=NULL )
    {
     printf( «Error in phrase generator!\n» );
    }

   printf( «#%2d «, i );
   wide(phrase);
   printf( «\n» );
   sol_DeleteGeneratedPhrase(phrase);
  }

 Imitate( L»..\\..\\..\\..\\..\\..\\scripts\\rewriter\\etalons-en.txt», ENGLISH_LANGUAGE );

 sol_DeletePhraseGenerator(hFG);