Как настроить проект C/C++ безопасно (организация файлов)

Question

У меня есть (большой) проект C/C++, который состоит из языков C и C++. В какой-то момент выяснилось, что существуют две функции C с одинаковыми именами. Эти функции определены в двух разных файлах * .c в разных местах. В целом на самом высоком уровне проект - C++. Эта проблема была поставлена ​​под сомнение и ответили here

Однако остается вопрос «как организовать эти файлы безопасно». Как я могу сгруппировать такой проект, чтобы не было конфликтов имен, и я могу быть уверен, что вызывается правильная функция. Будет ли писать обертку для каждой из этих функций?

Вот как это выглядит на данный момент: Ah // первое объявление функции F Ac // первое определение функции F

Bh // вторая декларация функции F Bc // второе определение функции F

пытается сделать такую ​​вещь:

extern "C"{ 
#include "A.h" 
#include "B.h" 
} 

причины название конечно конфликта. Что я могу сделать, чтобы избежать этого конфликта, и иметь надежный код? Будет ли такое решение помогло:

A_Wrapper.h: // C++

extern "C"{ 
#include "A.h" 
} 

void WrapF_A(int x) 
{ 
    F(x); 
} 

B_Wrapper.h: // C++

extern "C"{ 
#include "B.h" 
} 

void WrapF_B(int x) 
{ 
    F(x); 
} 

, а затем в программе:

#include A_Wrapper.h 
#include B_Wrapper.h 

Модирование каждого файла в этом проекте было бы весьма невозможным, поскольку оно было основано на сотнях файлов, и я, скорее всего, повредил бы какой-то код. Есть ли способ сделать файл include видимым только в какой-то части программы?

EDIT: Итак, я создал простой проект, иллюстрирующий проблему, и попытался применить подсказки, данные врачом. Однако все же происходит множественное определение ошибки F. Что я должен изменить? Файлы проекта:

хиджры:

#ifndef A_H_INCLUDED 
#define A_H_INCLUDED 

int F(int x); 

#endif // A_H_INCLUDED 

A.c

#include "A.h" 

int F(int x) 
{ 
    return x*x; 
} 

AWrapper.h:

#ifndef AWRAPPER_H_INCLUDED 
#define AWRAPPER_H_INCLUDED 

int AF(int x); 

#endif // AWRAPPER_H_INCLUDED 

AW.cpp:

#include "AWrapper.h" 
extern "C"{ 
#include "A.h" 
} 

int AF(int x) 
{ 
    return F(x); 
} 

B.h:

#ifndef B_H_INCLUDED 
#define B_H_INCLUDED 

int F(int x); 

#endif // B_H_INCLUDED 

B.c:

#include "B.h" 

int F(int x) 
{ 
    return -x*x; 
} 

BWrapper.h:

#ifndef BWRAPPER_H_INCLUDED 
#define BWRAPPER_H_INCLUDED 

int BF(int x); 

#endif // BWRAPPER_H_INCLUDED 

BW.каст:

#include "BWrapper.h" 
extern "C"{ 
#include "B.h" 
} 

int BF(int x) 
{ 
    return F(x); 
} 

Answer 1

Go с оберточной идеей, но написать facade (см также here), который предоставляет то, что вам нужно от А, и то, что вам нужно от B не все функции в там.

Вы будете в конечном итоге с чем-то вроде

//header Wrap_A.h 
#ifndef WRAP_A_INCLUDED 
#define WRAP_A_INCLUDED 

//for some input Data left as an exercise for the reader... 
double solve_with_A(Data data); 

#endif 

//header Wrap_B.h 
#ifndef WRAP_B_INCLUDED 
#define WRAP_B_INCLUDED 

//for some input Data... 
double solve_with_B(Data data); 

#endif 

Затем сделайте два CPP файлы, которые включают в себя все конфликтующие заголовки файлов, те из A в a.cpp и те из B в B.cpp, поэтому конфликтов не бывает. Функции solve_with_A и solve_with_B затем вызовут все необходимое, не пропуская их на всю программу и не создавая конфликтов.

Возможно, вам придется подумать над тем, что на самом деле должно быть Data. Вы можете определить свои собственные типы, один для A и один для B. Просто не раскрывайте детали реализации в своих заголовках обертки/фасада.
Если заголовки причиняют вам боль, брандмауэр их в непослушный угол.

---

EDIT

Учитывая у вас есть две функции, F, если вы сложите все источники в один проект линкер должен и будет жаловаться, что он может увидеть и другое. Вместо этого вам нужно создать две статические библиотеки и просто выставить завернутую версию в ваш основной проект.