This is a newbie request. I’m looking for materials on .dll creation. Specifially, i want to create a .dll out of a simple 3D engine i’ve made to learn about the process. I need information on dynamic link libraries that go deeper than the wikipedia page, how are they created, what’s necessary, how to create different .dll files for “debug” and “release”, how to create a PDB file for it and how to create a header file that’ll allow for easy usage of the library from a, f.e., C++ program. Material with strong theoretical side (not as much, “how to create a dynamic link library in visual studio”) would be great.
Please share good materials on the subject, all i can find is some information here and there and it doesn’t paint the picture for me.
Reading between the lines, I think you really want to know about libraries in general rather than dll’s specifically. A library is simply a handy package of object (compiled) code, along with some information about how to call into it. In C++, this usually takes the form of a .h file.
With static libraries (.lib), the linker pulls in the code it needs in exactly the same way as it does with all the rest of your classes. A normal class will get compiled to object code (MyClass.obj), and when they’re all done the linker sticks them all together and wires up any inter-object calls with the appropriate addresses. It’s the identical process with .lib library files. You end up with a big ball of executable code which includes both your classes, and the library functions within it.
With a dynamic library (.dll), the only difference is that the linking (wiring) happens at runtime instead of at compile time, and the library object code remains in a separate ball – the dll file. When you compile your exe, all calls that use functions in the library are mapped to a stub function. When Windows loads the dll for you, it will stick the dll code into the same memory area as your process, and wire up the stub functions to the real functions that are now available.
The only other difference is that a dll must expose a function that Windows can call when it loads or unloads the dll, in case the dll wants to do any initial setting up / clearing down. This is traditionally called DllMain().
If you want to learn about libraries, I would concentrate on creating a static .lib first before worrying about dll’s. This is where most of the work is. Once you have a lib it is child’s play to turn it into a dll.
The main thing you need to think about when creating a library is how you are going to expose your API (Application Programming Interface). This is just which functions/classes you are going to expose to the people using your library. You don’t have to expose them all, but you do have to decide WHAT to expose. Are you just going to expose some C style functions, or are you going to expose entire objects? This is the real challenge when designing a library. You should try and make your API as easy to use, and obvious as possible if people (and you!) are going to find your library useful.
As for pdb files, differently named release/debug modules, and creating .h files. These are identical to when doing so in an exe.