<p>I'm curious about everyones practices when it comes to using or distributing libraries for an application that you write.</p>

<p>First of all, when developing your application do you link the debug or release version of the libraries? (For when you run your application in debug mode)</p>

<p>Then when you run your app in release mode just before deploying, which build of the libraries do you use?</p>

<p>How do you perform the switch between your debug and release version of the libraries? Do you do it manually, do you use macros, or whatever else is it that you do?</p>

I would first determine what requirements are needed from the library:
Debug/Release
Unicode support
And so on..
With that determined you can then create configurations for each combination required by yourself or other library users.
When compiling and linking it is very important that you keep that libraries and executable consistent with respect to configurations used i.e. don't mix release & debug when linking.
I know on the Windows/VS platform this can cause subtle memory issues if debug & release libs are mixed within an executable.
As Brian has mentioned to Visual Studio it's best to use the Configuration Manager to setup how you want each configuration you require to be built.
For example our projects require the following configurations to be available depending on the executable being built.
Debug+Unicode
Debug+ASCII
Release+Unicode
Release+ASCII
The users of this particular project use the Configuration Manager to match their executable requirements with the project's available configurations.
Regarding the use of macros, they are used extensively in implementing compile time decisions for requirements like if the debug or release version of a function is to be linked. If you're using VS you can view the pre-processor definitions attribute to see how the various macros are defined e.g. _DEBUG _RELEASE, this is how the configuration controls whats compiled.
What platform are you using to compile/link your projects?
EDIT: Expanding on your updated comment..
If the
Configuration Manager
option is not available to you then I recommend using the following properties from the project:
Linker
->
Additional Library Directories
or
Linker
->
Input
Use the macro
```
$(ConfigurationName)
```
to link with the appropriate library configuration e.g. Debug/Release.
```
```
$(ProjectDir)\..\third-party-prj\$(ConfigurationName)\third-party.lib
```
```
Build Events
or
Custom Build Step
configuration property
Execute a copy of the required library file(s) from the dependent project prior (or after) to the build occurring.
```
```
xcopy $(ProjectDir)\..\third-party-prj\$(ConfigurationName)\third-party.dll $(IntDir)
```
```
The macro
```
$(ProjectDir)
```
will be substituted for the current project's location and causes the operation to occur relative to the current project.
The macro
```
$(ConfigurationName)
```
will be substituted for the currently selected configuration (default is
```
Debug
```
or
```
Release
```
) which allows the correct items to be copied depending on what configuration is being built currently.
If you use a regular naming convention for your project configurations it will help, as you can use the
```
$(ConfigurationName)
```
macro, otherwise you can simply use a fixed string.