Can I pass std::string to a DLL?

by

You have a choice to make:

  • Tightly coupled DLL: The DLL is built with the exact same compiler version, packing and calling convention settings, library options as the application, and both dynamically link to the runtime library (/MD compiler option). This lets you pass objects back and forth including STL containers, allocate DLL objects from inside the application, derive from base classes in the other module, do just about everything you could without using DLLs. The disadvantage is that you can no longer deploy the DLL independently of the main application. Both must be built together. The DLL is just to improve your process startup time and working set, because the application can start running before loading the DLL (using the /delayload linker option). Build times are also faster than a single module, especially when whole program optimization is used. But optimization doesn’t take place across the application-DLL boundary. And any non-trivial change will still require rebuilding both.

  • Loosely coupled: The application doesn’t depend on the class layout of objects defined by the DLL. You use only highly compatible data types: primitive types, pointers, function pointers, and user-defined types made up of these elements. Classes inherit from a base class which defines interface and has no data members and no non-virtual functions (this means no constructors and no sharing of standard library objects such as std::string or CString). All allocation and object creation must be done through a factory function. Memory must be deallocated from the module which allocated it. Code and data are separated. The header file explicitly states the calling convention of each exported function and packing of each structure allowed to cross module boundaries. The advantage is that the DLL and application can be updated completely independently. You can rebuild one with a new runtime library, new compiler version, or even in a completely new language, and don’t have to even touch the other.

I always advise using the loosely coupled approach.

More Related Contents:

  1. Why does this program crash: passing of std::string between DLLs
  2. Memory allocation and deallocation across dll boundaries
  3. Avoid memory leaks in C++ Pointers [closed]
  4. C++ – destructors [closed]
  5. delete vs delete[] [duplicate]
  6. How to get memory usage at runtime using C++?
  7. Registering a CPP dll into COM after installation using Wix Msi installer
  8. Smart pointers: who owns the object? [closed]
  9. How do I programmatically get the version of a DLL or EXE file?
  10. Altering DLL search path for static linked DLL
  11. Why is stack memory size so limited?
  12. How to properly replace global new & delete operators
  13. DLL redirection using manifests
  14. How do you determine the size of an object in C++?
  15. AllocConsole() not displaying cout
  16. Initial capacity of vector in C++
  17. Why is there no reallocation functionality in C++ allocators?
  18. Is it safe to realloc memory allocated with new?
  19. What do I need to do before deleting elements in a vector of pointers to dynamically allocated objects?
  20. Implementing a std::vector like container without undefined behavior
  21. Excel VBA, Can’t Find DLL Entry Point from a DLL file
  22. How can I use Standard Library (STL) classes in my dll interface or ABI?
  23. Call destructor and then constructor (resetting an object)
  24. What’s the differences between .dll , .lib, .h files?
  25. How to track memory allocations in C++ (especially new/delete)
  26. The difference between delete and delete[] in C++ [duplicate]
  27. Windows & C++: extern & __declspec(dllimport)
  28. Using shared_ptr in dll-interfaces
  29. C++ How to compile dll in a .exe
  30. C++ static variable in .lib does not initialize

Leave a Comment