Implicitly linking DLL with VS2010 or earlier

You may be wondering what is "Implicit DLL linking". There are two way to link to a DLL one is "Implicit" another one is "explicit".

When you are the builder of the DLL or you have the exported symbol definition file or the exported lib, you can add the DLL simply by incorporating the .DEF (definition file) or the .lib file to the project properties.

But when you do not have the any of the things mentioned above, you have to load the DLL explicitly by using "LoadLibrary" win32 API, get the function pointer by calling "GetProcAddress" and the calling the function using the function pointer.

Today I am going to discuss how to "Implicit" link DLL file into your application.

First open a DLL project - usually a win32 project.

Then select DLL from the next window to open the project as a DLL project.

Next I am going to add a header file called Math.h and add some basic function there. which I will export through DLL and use it in a console application.

the Math.h file

#pragma once
class __declspec(dllexport) Math {
public:
    int add(int a, int b);
    double sqr(double a);
}

and the cpp file

#include "Math.h"
int Math::add(int a, int b) {
    return (a+b);
}
double Math::sqr(double a) {
    return (a*a);
}

__declspec(dllexport) will tell the compiler that this class should be exported by the DLL for use in application.

Building this project will generate two components.

1. the DLL file itselfv [myDLL.dll]

2. a lib file which holds the necessary stubs and initializations to call appropriate DLL function  [myDLL.lib]

to incorporate DLL into an application one has to include the .lib into project dependencies.

Thats all. Now you can build your application and use the DLL function very easily.

Hope this helps.

If you have any queries or suggestions, please leave a comment.

Optimizing the Code ... Optimizing the Solution

Sometimes developers are over excited about creating an optimized solution by optimizing & refactoring the code. They try to optimize every bit and line to their heart's content. Optimization is an art, but sometimes you gotta admit that overdoing any art, loses it's beauty. So, what optimization process should be followed? Well, I want to share my view on that matter.

Create a solution but don't bother about the "Perfect solution" 

          What good a highly optimized, well written & well maintained code base can do, when it can not solve the problem? The simple answer is nothing. Every solution is written so that it could solve a problem. If you are given a non working but nicely written application will you choose it over a badly coded working solution? I guess, you got the point.

Optimize the solution but never over do it 

          Then next state would be optimize the solution. After you have a solution you can make it more better. Break the function into small functions. Group the class into a module. Apply DP where appropriate.

The 90 - 10 rule

          Try to optimize the section which consumes most of the time. The 90 - 10 rule follows as -  10% of code constitutes 90% of total running time of the application. Have you ever think of any solution not having a loop? Have you seen a complex algorithm not having several loops? These loops are the CPU cycle hogger. They are the 10% out of 100% code. Try to optimize that 10% before optimizing other sections. Slight improvement over that 10% will leave a mark on the performance of your application.

Thank you for reading.