C / C++ / MFC

George_George wrote:

extern CFoo foo;

CFoo foo2;

class __declspec (dllexport) CFoo 
{
public:	
    CFoo();	
    int foo1();	
    int foo2();
};

__declspec (dllexport) CFoo foo;re>

Foo.cpp
<pre>#include "Foo.h"

CFoo::CFoo()
{	
    return;
}
int CFoo::foo1()
{	
    return 100;
}
int CFoo::foo2()
{	
    return 200;
}

and here is the console based application code -
Foo.h

class __declspec (dllimport) CFoo
{
public:	
    CFoo();	
    int foo1();	
    int foo2();
};

__declspec (dllimport) CFoo foo; 

test.cpp
#include "foo.h"
int main()
{	
    int i = foo.foo1();	
    i = foo.foo2();	
    return 0;
}

Don't forget to set the dependency to Foo.lib file in the test project settings.
Hope this will help.

George_George wrote:

CFoo foo;

George_George wrote:

extern CFoo foo;

George_George wrote:

could I use extern to refer to the variable and use it?

George_George wrote:

So, from learning from you, it is legal to expose both function/global variable/class from a DLL?

// foo.h

#ifdef _DLLPROJ_
#define DLLEXP __declspec (dllexport)
#else 
#define DLLEXP __declspec (dllimport)
#endif

DLLEXP class CFoo
{
public:

	DLLEXP int foo1();

	DLLEXP int foo2();
};

DLLEXP class CFooImpl : CFoo
{
public:

	DLLEXP CFooImpl();

	DLLEXP int foo1();

	DLLEXP int foo2();
};

// dllmain.cpp

#include "foo.h"

CFooImpl::CFooImpl()
{
	return;
}

int CFooImpl::foo1()
{
	return 100;
}

int CFooImpl::foo2()
{
	return 200;
}

DLLEXP CFooImpl foo;

// main.cpp

#include "foo.h"

DLLEXP CFooImpl foo;

int main()
{
	CFooImpl foo1;

	int i = foo.foo1();
	i = foo.foo2();

	return 0;
}

George_George wrote:

DLLEXP class CFoo

#if!defined(COMMONLIB_API)
#ifdef COMMONLIB_EXPORTS
#define COMMONLIB_API __declspec(dllexport)
#else
#define COMMONLIB_API __declspec(dllimport)
#endif
#endif

namespace MyAppLibrary {

   class MessageReporter {

      public:

         //ctor
         COMMONLIB_API MessageReporter();

         //Add new reporting function
         COMMONLIB_API static void AddReportFunction(ReportFnPtr func);

         //Set MessageReporter Level on or off
         COMMONLIB_API static void SetReporterLevel(Level lev, bool on);

         //Set all levels to on
         COMMONLIB_API static void AllLevelsOn() {repLevels=~0;}

         //Set all levels to off
         COMMONLIB_API static void AllLevelsOff() {repLevels=0;}
   };
};

a.h

#if !defined(__A_H__)
#define __A_H__

#if!defined(A_API)
#ifdef A_EXPORTS
#define A_API __declspec(dllexport)
#else
#define A_API __declspec(dllimport)
#endif
#endif

class A_API A
{
public:
    A();
    A(int a);
    void DoSomething(int b);
    int Result() const;
private:
    int a_;
};

#endif // !defined(__A_H__)

a.cpp

#include <windows.h>
#define A_EXPORTS
#include "a.h"

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    return TRUE;
}

A::A() : a_(0) {}
A::A(int a) : a_(a) {}
void A::DoSomething(int b) { a_ += b; }
int A::Result() const { return a_; }

b.cpp

#include <iostream>
#include "a.h"

int main(int argc, char** argv)
{
    A a(argc);
    
    a.DoSomething(3);
    std::cout << a.Result() << std::endl;
}

1. In main.cpp, you want to declare CFoo as __declspec(dllimport). The way I do that is to put something like this in foo.h:
   
   

   #if !defined(FOO_DLL)
   #define FOO_EXP __declspec(dllimport)
   #else
   #define FOO_EXP __declspec(dllexport)
   #endif
   
   class FOO_EXP CFoo { ... };

   
   
   You would define FOO_DLL when building the DLL using, for example, #define FOO_DLL in every source file in the DLL before #including foo.h. You need do nothing in main.cpp>/code>, as that's what the default case caters for.
2. As other replies have said, you would need to export CFoo foo; from the DLL.