linux- windows cross application c ++

Je développe une application qui doit fonctionner sous Linux et Windows. J’ai un object appelé obj que je veux utiliser dans le code et il a un comportement différent sous Linux et Windows. J’ai donc hérité aaa et appelé WindowsObj pour object Windows et LinuxObj pour object Linux.

Ma question est la suivante: comment utiliser cet object dans le code? Que dois-je écrire pour que ça fonctionne à la fois pour Linux et Windows?

Pour les types de swiching, j’utilise typedef comme:

typedef uint32_t DWORD;

mais que dois-je utiliser pour les objects? Je veux écrire ce code:

 tr1::shared_ptr windowsobj (new WindowsObj(parameter)); tr1::shared_ptr linuxobj (new LinuxObj(parameter));

Une idée?

La même chose 🙂

 class _object { }; class WindowsObject : public _object { }; class LinuxObject public _object { }; #if defined(WIN32) typedef WindowsObject Object; #else typedef LinuxObject Object; #endif Object myObject;

EDIT: Bien entendu, l’interface exposée par WindowsObject et LinuxObject doit être identique. Dans cet exemple, _object serait une classe de base abstraite définissant l’interface, et LinuxObject et WindowsObject implémenteraient alors cette interface, en masquant les éléments spécifiques à la plateforme dans leurs fichiers d’implémentation.

Échantillon

_object.h

 class _object { public: virtual void doSomething() = 0; }; // eo class _object

WindowsObject.h

 #include "_object.h" class WindowsObject : public _object { public: virtual void doSomething(); }; // eo class WindowsObject

WindowsObject.cpp

 #if defined(WIN32) #include  void WindowsObject::doSomething() { // do something totally reliant on windows here }; // eo doSomething #endif

Ensuite, vous feriez la même chose pour LinuxObject.h et LinuxObject.cpp , ce dernier ayant des instructions de préprocesseur complètement différentes. par exemple, #if defined(UNIX) ou une telle saveur. Notez les gardes WIN32 autour de l’implémentation. Vous auriez alors un fichier d’en-tête principal que vous utiliseriez:

 #if defined(WIN32) #include "WindowsObject.h" typedef WindowsObject Object; #else #include "LinuxObject.h" typedef LinuxObject Object; #endif

Maintenant, dans votre programme

 Object a; a.doSomething();

Il est intéressant de noter que si ce n’est que la ligne de code étrange qui diffère dans votre object complexe (comme un appel initial à l’initialisation, la destruction), vous feriez mieux d’utiliser un seul object indépendant de la plate-forme et de placer des gardes dans l’implémentation. Cette solution a plus de sens quand il y a des différences énormes.

J’ai tendance à utiliser la compilation conditionnelle pour cela, par exemple

 #ifdef WIN32 // windows-specific code #else // non-windows #endif

Je suggère d’utiliser un framework multi-plateforme, comme GTK + ou wxWidgets, pour ne pas avoir à réinventer la roue …

Ensuite, vous devriez avoir le code le moins possible dépendant de la plate-forme, et peut-être même au plus profond de vos classes. Là, vous pouvez utiliser #ifdef pour inclure conditionnellement du code pour Windows ou pour Unix.

Vous pouvez utiliser le même fichier d’en-tête avec deux implémentations différentes dans deux fichiers .cpp différents. l’ idiome PIMPL rend cela possible même si les deux implémentations nécessitent des membres de données complètement différents. Vous comstackz et liez simplement une source lors de la compilation pour Windows et une autre pour la compilation pour Linux.

Un domaine que j’ai trouvé utile pour les interfaces de messagerie. Les deux systèmes d’exploitation ont des méthodes complètement différentes pour envoyer des emails.

Salut si vous pouvez utiliser c ++, utilisez boost et taille_t le mieux.