Procédure pas à pas : Créer et utiliser votre propre bibliothèque de liens dynamiques (C++)

Cette procédure pas à pas montre comment utiliser l’IDE Visual Studio pour créer votre propre bibliothèque de liens dynamiques (DLL) écrite dans Microsoft C++ (MSVC). Il montre ensuite comment utiliser la DLL à partir d’une autre application C++. Les DLL (également appelées bibliothèques partagées dans les systèmes d’exploitation UNIX) sont l’un des types les plus utiles de composants Windows. Vous pouvez les utiliser comme moyen de partager du code et des ressources, et de réduire la taille de vos applications. Les DLL peuvent même faciliter le service et l’extension de vos applications.

Dans cette procédure pas à pas, vous allez créer une DLL qui implémente certaines fonctions mathématiques. Ensuite, vous allez créer une application console qui utilise les fonctions de la DLL. Vous allez également découvrir certaines des techniques et conventions de programmation utilisées dans les DLL Windows.

Cette procédure pas à pas couvre les tâches suivantes :

• Créer un projet DLL dans Visual Studio.

• Ajouter des fonctions et des variables exportées à la DLL.

• Créez un projet d’application console dans Visual Studio.

• Utilisez les fonctions et variables importées à partir de la DLL dans l’application console.

• Exécutez l’application terminée.

Comme une bibliothèque liée statiquement, une DLL exporte des variables, des fonctions et des ressources par nom. Une application cliente importe les noms pour utiliser ces variables, fonctions et ressources. Contrairement à une bibliothèque liée statiquement, Windows connecte les importations dans votre application aux exportations dans une DLL au moment du chargement ou au moment de l’exécution, au lieu de les connecter au moment de la liaison. Windows requiert des informations supplémentaires qui ne font pas partie du modèle de compilation standard C++ pour établir ces connexions. Le compilateur MSVC implémente certaines extensions spécifiques dans C++ pour fournir ces informations supplémentaires. Nous allons expliquer ces extensions au fur et à mesure.

Cette procédure pas à pas crée deux solutions Visual Studio ; une qui crée la DLL et une qui crée l’application cliente. La DLL utilise la convention d’appel C. Il peut être appelé à partir d’applications écrites dans d’autres langages de programmation, tant que la plateforme, les conventions d’appel et les conventions de liaison correspondent. L’application cliente utilise liaison implicite, où Windows lie l’application à la DLL au moment du chargement. Cette liaison permet à l’application d’appeler les fonctions fournies par la DLL, telles que les fonctions dans une bibliothèque liée statiquement.

Cette procédure pas à pas n’aborde pas quelques situations courantes. Le code n’affiche pas l’utilisation de DLL C++ par d’autres langages de programmation. Il ne montre pas comment créer une DLL de ressource uniquement ou comment utiliser une liaison explicite pour charger des DLL au moment de l’exécution plutôt qu’au moment du chargement. Restez assuré que vous pouvez utiliser MSVC et Visual Studio pour effectuer toutes ces opérations.

Même si le code de la DLL est écrit en C++, nous avons utilisé des interfaces de style C pour les fonctions exportées. Il existe deux raisons principales pour cela : Tout d’abord, de nombreux autres langages prennent en charge les importations de fonctions de style C. L’application cliente n’a pas besoin d’être écrite en C++. Ensuite, il évite certains pièges courants liés aux classes exportées et aux fonctions membres. Il est facile de faire des erreurs difficiles à diagnostiquer lors de l’exportation de classes, car tout ce qui fait référence dans une déclaration de classe doit avoir une instanciation qui est également exportée. Cette restriction s’applique aux DLL, mais pas aux bibliothèques statiques. Si vos classes sont de style simple de données anciennes, vous ne devez pas résoudre ce problème.

Pour obtenir des liens vers d’autres informations sur les DLL, consultez Créer des DLL C/C++ DLL dans Visual Studio. Pour plus d’informations sur la liaison implicite et la liaison explicite, consultez Déterminer la méthode de liaison à utiliser. Pour plus d’informations sur la création de DLL C++ à utiliser avec des langages de programmation qui utilisent des conventions de liaison de langage C, consultez Exportation des fonctions C++ pour une utilisation dans les exécutables en langage C. Pour plus d’informations sur la création de DLL à utiliser avec les langages .NET, consultez Appel de fonctions DLL à partir d’applications Visual Basic.

Prérequis

• Un ordinateur qui exécute Microsoft Windows 7 ou versions ultérieures. Nous vous recommandons la dernière version de Windows pour la meilleure expérience de développement.

• Une compréhension des principes fondamentaux de l’utilisation de l’IDE Visual Studio. Si vous avez déjà utilisé des applications de bureau Windows, vous n’aurez probablement aucun mal à suivre. Pour une introduction, consultez Visite guidée des fonctionnalités de l’IDE Visual Studio.

• Une compréhension de suffisamment de notions de base du langage C++ pour pouvoir suivre. Ne vous inquiétez pas, nous ne faisons rien de bien compliqué.

Créer le projet DLL

Dans cet ensemble de tâches, vous créez un projet pour votre DLL, ajoutez du code et générez-le. Pour commencer, démarrez l’IDE Visual Studio et connectez-vous si nécessaire. Les instructions varient légèrement selon la version de Visual Studio que vous utilisez. Assurez-vous que vous avez sélectionné la version correcte dans le contrôle en haut à gauche de cette page.

Pour l’instant, cette DLL ne fait pas grand-chose. Ensuite, vous allez créer un fichier d’en-tête pour déclarer les fonctions que vos DLL exporte, puis ajouter les définitions de fonction à la DLL pour le rendre plus utile.

Pour ajouter un fichier d’en-tête à la DLL

1. Pour créer un fichier d'en-tête pour vos fonctions, dans la barre de menus, choisissez Projet>Ajouter un nouvel élément.

2. Dans le volet gauche de la boîte de dialogue Ajouter un nouvel élément, sélectionnez Visual C++. Dans le volet central, sélectionnez Fichier d’en-tête (.h). Spécifiez MathLibrary.h comme nom pour le fichier d’en-tête.

   

3. Choisissez le bouton Ajouter pour générer un fichier d’en-tête vide, qui s’affiche dans une nouvelle fenêtre d’éditeur.

   

4. Remplacez le contenu du fichier d’en-tête par ce code :

   // MathLibrary.h - Contains declarations of math functions
   #pragma once
   
   #ifdef MATHLIBRARY_EXPORTS
   #define MATHLIBRARY_API __declspec(dllexport)
   #else
   #define MATHLIBRARY_API __declspec(dllimport)
   #endif
   
   // The Fibonacci recurrence relation describes a sequence F
   // where F(n) is { n = 0, a
   //               { n = 1, b
   //               { n > 1, F(n-2) + F(n-1)
   // for some initial integral values a and b.
   // If the sequence is initialized F(0) = 1, F(1) = 1,
   // then this relation produces the well-known Fibonacci
   // sequence: 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
   
   // Initialize a Fibonacci relation sequence
   // such that F(0) = a, F(1) = b.
   // This function must be called before any other function.
   extern "C" MATHLIBRARY_API void fibonacci_init(
       const unsigned long long a, const unsigned long long b);
   
   // Produce the next value in the sequence.
   // Returns true on success and updates current value and index;
   // false on overflow, leaves current value and index unchanged.
   extern "C" MATHLIBRARY_API bool fibonacci_next();
   
   // Get the current value in the sequence.
   extern "C" MATHLIBRARY_API unsigned long long fibonacci_current();
   
   // Get the position of the current value in the sequence.
   extern "C" MATHLIBRARY_API unsigned fibonacci_index();
   

Ce fichier d’en-tête déclare certaines fonctions pour produire une séquence Fibonacci généralisée avec deux valeurs initiales. Un appel à fibonacci_init(1, 1) génère la séquence familière de nombres Fibonacci.

Notez les instructions du préprocesseur en haut du fichier. Le nouveau modèle de projet pour un projet DLL ajoute <PROJECTNAME>_EXPORTS aux macros de préprocesseur définies. Dans cet exemple, Visual Studio définit MATHLIBRARY_EXPORTS quand votre projet DLL MathLibrary est généré.

Lorsque la MATHLIBRARY_EXPORTS macro est définie, la MATHLIBRARY_API macro définit le __declspec(dllexport) modificateur sur les déclarations de fonction. Ce modificateur indique au compilateur et à l’éditeur de liens d’exporter une fonction ou une variable à partir de la DLL à utiliser par d’autres applications. Lorsqu’il MATHLIBRARY_EXPORTS n’est pas défini, par exemple, lorsque le fichier d’en-tête est inclus par une application cliente, MATHLIBRARY_API applique le __declspec(dllimport) modificateur aux déclarations. Ce modificateur optimise l'importation de la fonction dans une application. Pour plus d’informations, consultez dllexport, dllimport.

Pour ajouter une implémentation à la DLL

Pour vérifier que tout fonctionne à ce stade, compilez la bibliothèque de liens dynamiques. Pour ce faire, choisissez Créer>Créer des solution dans la barre de menus. La DLL et la sortie du compilateur associée sont placées dans un dossier appelé Déboguer directement sous le dossier solution. Si vous créez une build Release, la sortie est placée dans un dossier appelé Release. Le résultat doit ressembler à ce qui suit :

1>------ Build started: Project: MathLibrary, Configuration: Debug Win32 ------
1>pch.cpp
1>dllmain.cpp
1>MathLibrary.cpp
1>Generating Code...
1>   Creating library C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.lib and object C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.exp
1>MathLibrary.vcxproj -> C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.dll
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

1>------ Build started: Project: MathLibrary, Configuration: Debug Win32 ------
1>stdafx.cpp
1>dllmain.cpp
1>MathLibrary.cpp
1>Generating Code...
1>   Creating library C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.lib and object C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.exp
1>MathLibrary.vcxproj -> C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.dll
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

1>------ Build started: Project: MathLibrary, Configuration: Debug Win32 ------
1>MathLibrary.cpp
1>dllmain.cpp
1>Generating Code...
1>   Creating library C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.lib and object C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.exp
1>MathLibrary.vcxproj -> C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.dll
1>MathLibrary.vcxproj -> C:\Users\username\Source\Repos\MathLibrary\Debug\MathLibrary.pdb (Partial PDB)
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

Félicitations, vous avez créé une DLL à l’aide de Visual Studio ! Ensuite, vous allez créer une application cliente qui utilise les fonctions exportées par la DLL.

Créer une application cliente qui utilise la DLL

Lorsque vous créez une DLL, réfléchissez à la façon dont les applications clientes peuvent l’utiliser. Pour appeler les fonctions ou accéder aux données exportées par une DLL, le code source du client doit disposer des déclarations disponibles au moment de la compilation. Au moment du lien, l’éditeur de liens nécessite des informations pour résoudre les appels de fonction ou les accès aux données. Une DLL fournit ces informations dans une bibliothèque d’importation, un fichier qui contient des informations sur la façon de rechercher les fonctions et les données, au lieu du code réel. Et en cours d’exécution, la DLL doit être à la disposition du client à un emplacement que le système d’exploitation peut trouver.

Qu’il s’agisse de votre propre ou d’un tiers, votre projet d’application cliente a besoin de plusieurs informations pour utiliser une DLL. Il doit rechercher les en-têtes qui déclarent les exportations DLL, les bibliothèques d’importation pour l’éditeur de liens et la DLL elle-même. Une solution consiste à copier tous ces fichiers dans votre projet client. Pour les DLL de tiers qui sont peu susceptibles de changer pendant le développement de votre client, cette méthode peut être la meilleure façon de les utiliser. Toutefois, lorsque vous créez également la DLL, il est préférable d’éviter la duplication. Si vous effectuez une copie locale de fichiers DLL en cours de développement, vous pouvez modifier accidentellement un fichier d’en-tête dans une copie, mais pas l’autre, ou utiliser une bibliothèque obsolète.

Pour éviter tout code hors synchronisation, nous vous recommandons de définir le chemin d’accès include dans votre projet client pour inclure les fichiers d’en-tête DLL directement à partir de votre projet DLL. Définissez également le chemin de la bibliothèque dans votre projet client pour inclure les bibliothèques d’importation DLL à partir du projet DLL. Enfin, copiez la DLL générée à partir du projet DLL dans votre répertoire de sortie de build client. Cette étape permet à votre application cliente d’utiliser le code DLL que vous créez.

Ensuite, pour appeler les fonctions MathLibrary dans votre code source, votre projet doit inclure le fichier MathLibrary.h . Vous pouvez copier ce fichier d’en-tête dans votre projet d’application cliente, puis l’ajouter au projet comme élément existant. Cette méthode peut être un bon choix pour des bibliothèques tierces. Toutefois, si vous travaillez sur le code de votre DLL et de votre client en même temps, les fichiers d’en-tête peuvent être synchronisés. Pour éviter ce problème, définissez le chemin des répertoires Include supplémentaires dans votre projet pour inclure le chemin d’accès à l’en-tête d’origine.

Pour ajouter l’en-tête de la DLL à votre chemin Include

1. Cliquez avec le bouton droit sur le nœud MathClient dans l’Explorateur de solutions pour ouvrir la boîte de dialogue Pages de propriétés.

2. Dans la zone de liste déroulante Configuration , sélectionnez Toutes les configurations s’il n’est pas déjà sélectionné.

3. Dans le volet gauche, sélectionnez Propriétés>de configuration C/C++>Général.

4. Dans le volet des propriétés, sélectionnez le contrôle de la liste déroulante en regard de la zone d’édition pour Autres répertoires Include, puis choisissez Modifier.

   

5. Double-cliquez dans le volet supérieur de la boîte de dialogue Autres répertoires Include pour activer un contrôle d’édition. Vous pouvez également choisir l’icône de dossier pour créer une entrée.

6. Dans le contrôle d’édition, spécifiez le chemin de l’emplacement du fichier d'en-tête MathLibrary.h. Vous pouvez choisir le contrôle de sélection (...) pour accéder au dossier approprié.

   Vous pouvez également entrer un chemin relatif de vos fichiers sources clients vers le dossier qui contient les fichiers d’en-tête DLL. Si vous avez suivi les instructions pour placer votre projet client dans une solution distincte de la DLL, le chemin relatif doit ressembler à ceci :

   ..\..\MathLibrary\MathLibrary

   Si vos projets DLL et clients se trouvent dans la même solution, le chemin d’accès relatif peut ressembler à ceci :

   ..\MathLibrary

   Lorsque les projets DLL et clients se trouvent dans d’autres dossiers, ajustez le chemin d’accès relatif à la correspondance. Vous pouvez également utiliser le contrôle de sélection pour rechercher le dossier.

   

7. Une fois que vous avez entré le chemin d’accès au fichier d’en-tête dans la boîte de dialogue Répertoires Include supplémentaires, choisissez le bouton OK . Dans la boîte de dialogue Pages de propriétés, choisissez le bouton OK pour enregistrer vos modifications.

Vous pouvez désormais inclure le fichier MathLibrary.h et utiliser les fonctions qu’il déclare dans votre application cliente. Remplacez le contenu de MathClient.cpp à l’aide de ce code :

// MathClient.cpp : Client app for MathLibrary DLL.
// #include "pch.h" Uncomment for Visual Studio 2017 and earlier
#include <iostream>
#include "MathLibrary.h"

int main()
{
    // Initialize a Fibonacci relation sequence.
    fibonacci_init(1, 1);
    // Write out the sequence values until overflow.
    do {
        std::cout << fibonacci_index() << ": "
            << fibonacci_current() << std::endl;
    } while (fibonacci_next());
    // Report count of values written before overflow.
    std::cout << fibonacci_index() + 1 <<
        " Fibonacci sequence values fit in an " <<
        "unsigned 64-bit integer." << std::endl;
}

Ce code peut être compilé, mais pas lié. Si vous générez l’application cliente maintenant, la liste d’erreurs affiche plusieurs erreurs LNK2019. Cela est dû au fait que votre projet ne contient pas encore d’informations : vous n’avez pas encore spécifié que votre projet dépend de la bibliothèque MathLibrary.lib . Et vous n’avez pas dit à l’éditeur de liens comment trouver le fichier MathLibrary.lib .

Pour résoudre ce problème, vous pouvez copier le fichier de bibliothèque directement dans votre projet d’application cliente. L’éditeur de liens trouve et l’utilise automatiquement. Toutefois, si la bibliothèque et l’application cliente sont en cours de développement, cela peut entraîner des modifications dans une copie qui ne sont pas affichées dans l’autre. Pour éviter ce problème, vous pouvez définir la propriété Dépendances supplémentaires pour indiquer au système de build que votre projet dépend de MathLibrary.lib. Vous pouvez également définir un chemin d’accès supplémentaire aux répertoires de bibliothèque dans votre projet pour inclure le chemin d’accès à la bibliothèque d’origine lorsque vous liez.

Pour ajouter la bibliothèque d’importation DLL à votre projet

1. Cliquez avec le bouton droit sur le nœud MathClient dans Explorateur de solutions et choisissez Propriétés pour ouvrir la boîte de dialogue Pages de propriétés.

2. Dans la zone de liste déroulante Configuration , sélectionnez Toutes les configurations s’il n’est pas déjà sélectionné. Elle garantit que toutes les modifications de propriété s’appliquent aux builds Debug et Release.

3. Dans le volet gauche, sélectionnez Entrée de l’éditeur de>liens Propriétés>de configuration. Dans le volet des propriétés, sélectionnez le contrôle de la liste déroulante en regard de la zone d’édition pour les Dépendances supplémentaires, puis choisissez Modifier.

   

4. Dans la boîte de dialogue Dépendances supplémentaires, ajoutez MathLibrary.lib à la liste dans le contrôle d’édition supérieur.

   

5. Choisissez OK pour revenir à la boîte de dialogue Pages de propriétés.

6. Dans le volet gauche, sélectionnez Éditeur de liens Propriétés>>de configuration Général. Dans le volet des propriétés, sélectionnez le contrôle de la liste déroulante en regard de la zone d’édition pour Répertoires de bibliothèques supplémentaires, puis choisissez Modifier.

   

7. Double-cliquez dans le volet supérieur de la boîte de dialogue Répertoires de bibliothèques supplémentaires pour activer un contrôle d’édition. Dans le contrôle d’édition, spécifiez le chemin de l’emplacement du fichier MathLibrary.lib. Par défaut, il se trouve dans un dossier appelé Déboguer directement sous le dossier de solution DLL. Si vous créez une build de mise en production, le fichier est placé dans un dossier appelé Release. Vous pouvez utiliser la $(IntDir) macro pour que l’éditeur de liens puisse trouver votre DLL, quel que soit le type de build que vous créez. Si vous avez suivi les instructions pour placer votre projet client dans une solution distincte du projet DLL, le chemin relatif doit ressembler à ceci :

   ..\..\MathLibrary\$(IntDir)

   Si vos projets DLL et clients se trouvent dans d’autres emplacements, ajustez le chemin relatif à la correspondance.

   

8. Une fois que vous avez saisi le chemin du fichier de bibliothèque dans la boîte de dialogue Répertoires de bibliothèques supplémentaires, choisissez le bouton OK pour revenir à la boîte de dialogue Pages de propriétés. Choisissez OK pour enregistrer les modifications de propriété.

Votre application cliente peut maintenant compiler et lier correctement, mais elle n’a toujours pas tout ce dont elle a besoin pour s’exécuter. Lorsque le système d’exploitation charge votre application, il recherche la DLL MathLibrary. S’il ne la trouve pas dans certains répertoires du système, dans le chemin de l’environnement ou dans le répertoire de l’application locale, le chargement échoue. Selon le système d’exploitation, un message d’erreur semblable à celui-ci s’affiche :

Une façon d’éviter ce problème consiste à copier la DLL dans le répertoire qui contient votre exécutable client dans le cadre du processus de création. Vous pouvez ajouter un événement post-build à votre projet pour ajouter une commande qui copie la DLL dans votre répertoire de sortie de build. La commande spécifiée ici copie la DLL uniquement si elle est manquante ou a changé. Il utilise des macros pour copier vers et à partir des emplacements de débogage ou de mise en production, en fonction de votre configuration de build.

Pour copier la DLL dans un événement post-build

1. Cliquez avec le bouton droit sur le nœud MathClient dans Explorateur de solutions et choisissez Propriétés pour ouvrir la boîte de dialogue Pages de propriétés.

2. Dans la zone de liste déroulante Configuration, sélectionnez Toutes les configurations si ce n’est pas encore fait.

3. Dans le volet gauche, sélectionnez Événements>de génération de propriétés>de configuration après l’événement de build.

4. Dans le volet de propriétés, sélectionnez le contrôle d’édition dans le champ Ligne de commande. Si vous avez suivi les instructions pour placer votre projet client dans une solution distincte du projet DLL, entrez cette commande :

   xcopy /y /d "..\..\MathLibrary\$(IntDir)MathLibrary.dll" "$(OutDir)"

   Si vos projets DLL et clients se trouvent dans d’autres répertoires, modifiez le chemin relatif de la DLL pour qu’il corresponde.

   

5. Choisissez le bouton OK pour enregistrer les changements que vous avez apportés aux propriétés du projet.

Maintenant, votre application cliente a tout ce dont il a besoin pour générer et exécuter. Compilez l’application en sélectionnant Build, >Générer la solution dans la barre de menus. La fenêtre Sortie dans Visual Studio doit avoir quelque chose comme l’exemple suivant en fonction de votre version de Visual Studio :

1>------ Build started: Project: MathClient, Configuration: Debug Win32 ------
1>MathClient.cpp
1>MathClient.vcxproj -> C:\Users\username\Source\Repos\MathClient\Debug\MathClient.exe
1>1 File(s) copied
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

Félicitations, vous avez créé une application qui appelle des fonctions dans votre DLL. Exécutez maintenant votre application pour voir ce qu’elle fait. Dans la barre de menus, choisissez Déboguer>Démarrer sans débogage. Visual Studio ouvre une fenêtre de commande dans laquelle le programme doit exécuter. La dernière partie de la sortie doit avoir cette forme :

Appuyez sur une touche pour masquer la fenêtre de commande.

Maintenant que vous avez créé une DLL et une application cliente, vous pouvez faire des essais. Essayez de définir des points d’arrêt dans le code de l’application cliente et exécutez l’application dans le débogueur. Regardez ce qui se passe lorsque vous parcourez un appel de bibliothèque. Ajoutez d’autres fonctions à la bibliothèque, ou écrivez une autre application cliente qui utilise votre DLL.

Lorsque vous déployez votre application, vous devez également déployer les DLL qu’elle utilise. La façon la plus simple de rendre les DLL que vous générez, ou que vous incluez à partir de tiers, est de les placer dans le même répertoire que votre application. Il s’agit d’un déploiement local d’application. Pour plus d’informations sur le déploiement, consultez Deployment in Visual C++.

Voir aussi

Appel de fonctions de la DLL à partir d’applications Visual Basic