loading dll issue

[herrybiscuit]

so i was using a plugin system from this article: cplusplus.com/articles/48TbqMoL in my program using sdl2. i created a dll plugin to test the program and when i run the program using the dll the program's console starts printing a bunch of random strings and then crashes. i can't find any errors in the code and when i debugged the dll was loaded and all of the functions were too but when i call a function that returns a string it crashes. so all i can thing of that is causing this issue is a compiling error.

here is the code:

main.cpp:

#include <SDL.h>
#include <lua.hpp>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <Windows.h>
#include <vector>
#include <memory>

#include "conio.h"
#include "game.h"
#include "LTimer.h"
#include "modbase.hpp"

using namespace std;

game* g_game = new game;

LTimer capTimer;

const int FPS = 60;
int SCREEN_TICK_PER_FRAME = 1000 / FPS;

// Load the objects from the plugin folder.
//
// Takes as a parameter a reference to a list of modules,
// which will be emptied and then refilled with handles to
// the modules loaded. These should be freed with the
// FreeLibrary() after use.
//
// Returns a list of Base*, contained in a smart pointer
// to ease memory deallocation and help prevent memory
// leaks.
std::vector<std::unique_ptr<ModBase>> getPlugins(std::vector<HINSTANCE>& modules) {
	// A temporary structure to return.
	std::vector<std::unique_ptr<ModBase>> ret;
	// empty the modules list passed
	modules.clear();

	// Find the files contained in the 'plugins' folder
	WIN32_FIND_DATA fileData;
	HANDLE fileHandle = FindFirstFile(R"(mods\*.dll)", &fileData);

	if (fileHandle == (void*)ERROR_INVALID_HANDLE ||
		fileHandle == (void*)ERROR_FILE_NOT_FOUND) {
		// If we couldn't find any plugins, quit gracefully,
		// returning an empty structure.
		return std::vector<std::unique_ptr<ModBase>>();
	}

	// Loop over every plugin in the folder and store in our
	// temporary return list
	do {
		// Define the function types for what we are retrieving
		typedef std::unique_ptr<ModBase>(__cdecl *ObjProc)(void);
		typedef std::string(__cdecl *NameProc)(void);
		typedef void(__cdecl *InitProc)(void);

		// Load the library
		HINSTANCE mod = LoadLibrary((R"(mods\)" + std::string(fileData.cFileName)).c_str());

		if (!mod) {
			// Couldn't load the library, cleaning module list and quitting.
			for (HINSTANCE hInst : modules)
				FreeLibrary(hInst);
			throw std::runtime_error("Library " + std::string(fileData.cFileName) + " wasn't loaded successfully!");
		}

		// Get the function and the class exported by the DLL.
		// If you aren't using the MinGW compiler, you may need to adjust
		// this to cope with name mangling (I haven't gone into this here,
		// look it up if you want).
		ObjProc objFunc = (ObjProc)GetProcAddress(mod, "getObj");
		NameProc nameFunc = (NameProc)GetProcAddress(mod, "getName");
		InitProc initFunc = (InitProc)GetProcAddress(mod, "initDLL");

		if (!objFunc || !nameFunc || !initFunc)
			throw std::runtime_error("Invalid Plugin DLL: both 'getObj' , 'getName' and 'init' must be defined.");

		// push the objects and modules into our vectors
		ret.push_back(objFunc());
		modules.push_back(mod);

		clog << nameFunc() << endl;
		initFunc();

	} while (FindNextFile(fileHandle, &fileData));

	clog << endl;

	// Close the file when we are done
	FindClose(fileHandle);
	return ret;
}

//return a random string from a list of strings
string getRandStr()
{
	int r = rand() % 9 + 1;
	string returnStr;

	switch (r)
	{
	case 1:
		returnStr = "Spacey things!";
		break;
	case 2:
		returnStr = "Like the Oregon Trail!";
		break;
	case 3:
		returnStr = "3.1415926% Death!";
		break;
	case 4:
		returnStr = "Herry has dysentery..";
		break;
	case 5:
		returnStr = "Explosions!";
		break;
	case 6:
		returnStr = "I\'m sorry, Dave. I\'m afraid I can\'t do that.";
		break;
	case 7:
		returnStr = "It\'s a TRAP!";
		break;
	case 8:
		returnStr = "Mineing For Gold!";
		break;
	case 9:
		returnStr = "Get In The Ship!";
		break;
	case 10:
		returnStr = "Space For Dummies!";
		break;
	default:
		returnStr = "IMPOSSABREW";
		break;
	}
	return returnStr;
}

int main(int argc, char *argv[])
{
	std::vector<HINSTANCE> modules;

	// Enter a block, to prevent the Base objects being
	// deallocated after the modules are freed (which will
	// cause your program to crash)
	{

		//random seed
		srand(time(0));
		string name = getRandStr();
		//init game
		if (!g_game->g_init(name.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOW_SHOWN))
		{
			//best error ever
			cout << "well shit..." << endl;
			_getch();
			return 0;
		}
		else
		{
			//load media
			if (!g_game->g_loadMedia())
			{
				//throw this
				cout << "well shit..." << endl;
				_getch();
				return 0;
			}
			else
			{
				std::vector<std::unique_ptr<ModBase>> objs;
				// Load the plugins using our function
				try {
					objs = getPlugins(modules);
				}
				catch (const std::exception& e) {
					std::cerr << "Exception caught: " << e.what() << std::endl;
					_getch();
					return 1;
				}

				//successful load!
				cout << "-------------------------\nSuccessfully loaded!" << endl;

				while (!g_game->g_getStop())
				{
					capTimer.start();

					g_game->g_handleEvents();
					g_game->g_update();

					g_game->g_preRender();
					g_game->g_render();

					for (auto& x : objs) 
					{
						x->update();
						x->render();
					}

					g_game->g_aftRender();

					int frameTicks = capTimer.getTicks();
					if (frameTicks < SCREEN_TICK_PER_FRAME)
					{
						SDL_Delay(SCREEN_TICK_PER_FRAME - frameTicks);
					}
				}
			}
		}

		g_game->getFlieO();

		//close program
		for (HINSTANCE hInst : modules)
			FreeLibrary(hInst);

		delete g_game;
		g_game = NULL;
		return 0;
	}
}

modbase.hpp:

#ifndef __MODBASE_HPP_INCLUDED__
#define __MODBASE_HPP_INCLUDED__

#include <memory>
#include <string>

// Test to see if we are building a DLL.
// If we are, specify that we are exporting
// to the DLL, otherwise don't worry (we
// will manually import the functions).
#ifdef BUILD_DLL
#define DLLAPI __declspec(dllexport)
#else
#define DLLAPI
#endif // BUILD_DLL

// This is the base class for the class
// retrieved from the DLL. This is used simply
// so that I can show how various types should
// be retrieved from a DLL. This class is to
// show how derived classes can be taken from
// a DLL.
class ModBase {
public:
	virtual ~ModBase() = default;

	// Pure virtual function to render dll
	virtual void render(void) = 0;

	// Pure virtual function to update dll
	virtual void update(void) = 0;
};


// DLL export funcs

// Get an instance of the derived class
// contained in the DLL.
DLLAPI std::unique_ptr<ModBase> getObj(void);

// Get the name of the plugin. This can
// be used in various associated messages.
DLLAPI std::string getName(void);

//init the dll
DLLAPI void initDLL(void);

#endif // __MODBASE_HPP_INCLUDED__ 

mtestplugin.cpp:

#include "stdafx.h"
#include <iostream>
#include <cmath>
#include <windows.h>
#include <string>
#include "modbase.hpp"

class mtestplugin : public ModBase {
public:
	void render(void)
	{
	
	}

	void update(void)
	{
	
	}
};

std::string getName(void) {
	return std::string("a");
}

std::unique_ptr<ModBase> getObj(void) {
	return std::unique_ptr<ModBase>(new mtestplugin);
}

void initDLL(void)
{
	std::cout << "hia" << std::endl;
}

mtestplugin.def

LIBRARY mtestplugin
EXPORTS
  getObj
  getName
  initDLL

i have tried to fix this for weeks but nothing is working

[LB]

The problem is your getObj and getName functions. The issue with using DLLs is that they have to be built by the same compiler and with the exact same settings. If you build the application and DLL in different mods (e.g. Debug vs Release) they will have different definitions of the standard types like std::string and such. This means that while your DLL's getName function returns one kind of std::string, your application interprets it as a different kind of std::string with a different memory layout.

You must use types that will always remain the same between DLL and application regardless of compiler and/or build settings. Otherwise you will have to painstakingly track down which settings are different and make them the same.

[Avilius]

It's best to avoid the C++ STL altogether when making a DLL interface. If you want use it, by all means use it internally, but avoid it being used when trying to create an interface.

Good:

class ToExport
{
    public:
        void SetString(const char* newStr);
        const char* GetString() const;
    private:
        const char* str;
};

Not Good:

#include <string>

class ToExport
{
    public:
        void SetString (const std::string &newStr);
        std::string GetString() const;
    private:
        std::string str;
};

[LB]

Another consideration is structure member padding, which can vary.

[herrybiscuit]

i hate how the settings have to be exactly the same but ill just put it in the documentation for set up. thanks!

[Avilius]

Well it's something that really can't be helped due to the lack of a binary standard for C++. That's why it's preferred to use C for DLL interfacing.