Как управлять уникальными идентификаторами файлов в C++

Question

C++ (не C++ 11)

Скажем, у меня есть 100 файлов .cpp в моем проекте, которые в настоящее время выполняют некоторую работу. Все эти файлы в настоящее время содержат файл globals.h, который я могу легко редактировать.

Я хочу, чтобы каждый из этих файлов имел свой экземпляр какого-либо объекта, и я также хочу, чтобы этот экземпляр имел уникальный идентификатор файла, в котором он был создан. Кроме того, я хочу, чтобы эти объекты были созданы с помощью фабричного метода, и мне нужны экземпляры, чтобы иметь какой-то способ для пользователя обрабатывать их, то есть они не могут быть анонимными.

Вкратце - мне нужен способ генерации уникальных идентификаторов для всех файлов в моем проекте, мне нужен файл, чтобы иметь возможность доступа к его собственному идентификатору с использованием одного и того же имени во всех файлах, а также для возможности доступ к ID файла извне в другом файле «manager».

Вот варианты, которые не работают:

1. Enum:

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

static thePrivateInstanceInThisFile = theFactory.makeInstance(fileID); 

потому, что мне нужно в каждом файле другой fileID, и которая была определена статически, и уникальное имя с помощью моего перечисления.

2. класса, который считает свои собственные экземпляры

Определить в globals.h:

class FileIDGiver{ 
private: 
    static int currentID;//initialize to 0 in cpp 
    int myID; 
public: 
    FileIDGiver(){ 
     myID = currentID++; 
    } 
    int getFileID(){ 
     return myID; 
    } 
} 

static FileIDGiver theFileId; 

static thePrivateInstanceInThisFile = theFactory.makeInstance(theFileId.getFileID()); 

Это даст идентификатор каждого статического instace файла, который является уникальным для файла, но теперь он внешне не управляется файлом.

Я думал о делать что-то вроде

globals.cpp 
int file1ID; 
int file2ID; 
... 

globals.h 
extern file1ID; 
extern file2ID; 
... 

file1.cpp 
file1ID = theFileId.getFileID(); 

file2.cpp 
file2ID = theFileId.getFileID(); 

... 

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

Это позволит мне получить доступ к каждому уникальному и автоматически идентификатору файла извне. Единственная проблема, с которой я столкнулся, это линия file1ID = theFileId.getFileID(); выполняется только во время выполнения, ПОСЛЕ линии static thePrivateInstanceInThisFile = theFactory.makeInstance(theFileId.getFileID());. , который выполняется во время компиляции.

Я не могу найти хороший способ отменить этот заказ, или, может быть, сделать целый другой механик.

Опять же - мне нужно:

1. Автоматически создаваемые идентификаторы файлов

2. Уникальные идентификаторы файлов (которые очень очень предпочтительно числа)

3. Использование этих идентификаторов одним и тем же именем переменной во всех файлах (автоматически, используя определение статической переменной в глобалях.h файл)

4. Возможность доступа к конкретному идентификатору файла вручную с использованием другой вручную определенной переменной.

Пожалуйста посоветуйте хороший способ сделать это

Спасибо.

Answer 1

Если вы хотите иметь доступ к статическим Instance другим файлам, то это невозможно сделать с помощью автоматически генерируемого идентификатора, поскольку идентификатор, сгенерированный для файла, может меняться каждый раз при добавлении нового файла или каждый раз он компилируется или даже выполняется при каждом выполнении. Поэтому в этом решении каждый файл вручную определяет свой собственный постоянный идентификатор аналогично примеру 1 в вопросе.

---

ids.h

enum FileId 
{ 
    File1, File2, File3 
}; 

factory.h

#include "ids.h" 
#include "instance.h" 

class Factory 
{ 
    // ... 
public: 
    Factory() {/*...*/} 
    Instance createInstance(FileId fileid) {/*...*/} 
}; 

Factory &getTheFactory(); 

factory.cpp

#include "factory.h" 

Factory &getTheFactory() 
{ 
    static Factory theFactory; 
    return theFactory; 
} 

idmanager.h

#include "ids.h" 
#include "instance.h" 

template<FileId id> 
struct Manager 
{ 
    static Instance &getInstance(); // not defined 
}; 

global.h

#include "idmanager.h" 
#include "factory.h" 

template <> 
Instance &Manager<FILEID>::getInstance() 
{ 
    static Instance theInstance = getTheFactory().getInstance(FILEID); 
    return theInstance; 
}; 

static Instance &getThisFileInstance() 
{ 
    return Manager<FILEID>::getInstance(); 
} 

Использование выглядит следующим образом: для каждого файла, требующего статического Instance объекта, место на старте

#define FILEID File1 // The FileId corresponding to this file 
#include "global.h" 

Тогда в любой файл,

• Уникальный идентификатор задается FILEID. (извините, что это макрос)
• Статический Instance этого файла получен getThisFileInstance().
• Статический Instance любого файла получен Manager<any_file_id>::getInstance().

---

Это работает, помещая реализацию для конкретизации шаблона Manager<FileId> в каждом файле, каждый из которых создает и возвращает этот файл статику Instance.

Преимуществами являются постоянство идентификаторов и нулевые служебные данные: нет необходимости динамически назначать идентификаторы, а вызовы Manager<file_id>::getInstance() разрешаются во время компиляции.

Кроме того, заголовок ids.h может быть сгенерирован сценарием, который сканирует первую строку каждого файла для #define FILEID fileid, поэтому единственное оставшееся обслуживание оставляет за собой право записать #define FILEID fileid.

Answer 2

Это звучит как плохой случай static initialization order fiasco.

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

idgiver.h :

class IdGiver 
{ 
    int id; 
public: 
    IdGiver() : id(0) {} 
    int getId() {return id++;} 
}; 

IdGiver &getTheIdGiver(); 

idgiver.cpp:

#include "idgiver.h" 

IdGiver &getTheIdGiver() 
{ 
    static IdGiver theIdGiver; 
    return theIdGiver; 
} 

factory.h:

class Instance 
{ 
    // ... 
}; 

class Factory 
{ 
    // ... 
public: 
    Factory() : {/*...*/} 
    Instance getInstance(int id) {/*...*/} 
}; 

Factory &getTheFactory(); 

factory.cpp:

#include "factory.h" 

Factory &getTheFactory() 
{ 
    static Factory theFactory; 
    return theFactory; 
} 

globals.h:

#include "idgiver.h" 
#include "factory.h" 

static int  thisFileId  = getTheIdGiver().getId(); 
static Instance thisFileInstance = getTheFactory().getInstance(thisFileId); 

Answer 3

Вы можете модифицировать процедуру здания (например, ваш Makefile), чтобы определить какую-то уникальную вещь. Например. Вы можете компилировать foo23.cpp файл с чем-то вроде (предполагается, что GCC на некоторых системах Linux, адаптировать это к вашему компилятору и ОС и строитель)

g++ -Wall -c -DBASENAME="$(basename foo23.cpp)" -DUNIQUEID=23 

^{Вы можете получить 23 для UNIQUEID с помощью какой-то скрипт или что-то, например правило ad hoc в вашем Makefile. Подробности зависят от ваших соглашений об именах файлов.}

затем использовать надлежащим образом BASENAME и UNIQUEID в вашем C или C++ кода (возможно, с грязными #if UNIQUEID==23 препроцессора уловок ...).

Так что идея состоит в том, чтобы генерировать UNIQUEID в системе сборки и передать его через несколько символов препроцессора. Подробности - это ОС, компилятор, конкретная система сборки.

Вы можете также сделать некоторые сырой meta-programming генерируя некоторые C++ или источника или заголовка файла C (возможно, используя некоторые awk сценарий или некоторые GPP или m4 предварительной обработки) в вашей процедуре строительства.