Scontri quando si uniscono due progetti C

0

Sto avviando un nuovo progetto, che prenderà due progetti esistenti, userà parte delle funzionalità di ciascuno e aggiungerà nuove funzionalità.

Come al solito, entrambi i progetti non usano tipi C standard, preferendo typedef loro.

Tutto il codice è in C, non C ++, quindi ovviamente, entrambi i progetti volevano un tipo booleano, ed entrambi hanno typedef'd Bool , risultando in un errore del compilatore nel nuovo codice quando include entrambi i file di intestazione (l'esistente i progetti non conoscono nulla l'uno dell'altro e vanno benissimo)

Ovviamente, nessuna squadra vuole cambiare il suo codice (e potenzialmente destabilizzarlo).

E non c'è #if typedef .

Di seguito viene riportata la descrizione di Bad ascii art:

-------------       ---------------       -------------
| Project X |       | new project |       | Project Y |
-------------       ---------------       -------------
          \           /           \         /
           \         /             \       /
       ----------------           -------------- 
       |    X.h       |           |    Y.h     |
       ----------------           -------------- 

Dove sia x.h che y.h typedef Bool.

Devo essere in grado di costruire i progetti esistenti X e Y, oltre al nuovo progetto.

Come posso aggirare il problema della doppia definizione nel nuovo progetto (che richiede molte altre cose da x.h e y.h), e comunque essere in grado di costruire i progetti esistenti X e Y?

(Nota: il problema potrebbe essere maggiore di Bool , ma quello è il primo che emerge, quindi lo uso come esempio. Spero di non trovare due funzioni o enumerazioni con lo stesso nome).

Sto cercando una soluzione che, preferibilmente, non abbia alcun impatto sul codice esistente o abbia un impatto minimo sul codice esistente. Ho un'idea in mente, ma preferirei ascoltare gli altri, preferibilmente qualcuno che ha già fatto prima.

    
posta Mawg 05.05.2017 - 09:00
fonte

3 risposte

1

Sembra che il tuo primo problema sia il nome scontri.

Se entrambi i progetti definiscono effettivamente i tipi previsti nel modo previsto, allora potrebbe essere sufficiente semplicemente #undef della macro di contrasto immediatamente prima che sia #define 'd in entrambe le posizioni. Se facessero cose sottilmente diverse con esso, allora questo potrebbe introdurre sottili difetti; ma penso che in tal caso non andrai via senza immergerti in entrambe le basi di codice comunque.

    
risposta data 05.05.2017 - 09:10
fonte
1

Potresti creare un progetto "API" in cui muovi tutti i typedef duplicati e il progetto X e il progetto Y lo usano.

    
risposta data 05.05.2017 - 09:29
fonte
0

Hai pensato a:

#define Bool X_Bool
#include "X.h"
#undef Bool
#define Bool Y_Bool
#include "Y.h"
#undef Bool

Non è quello che definirei uso gestibile o ragionevole del preprocessore, ma funziona nel tuo caso.

    
risposta data 10.05.2017 - 22:12
fonte

Leggi altre domande sui tag