Globale const Char Zeiger-Array in C++

Question

Ich habe eine CONST Char Zeiger Array in Header-Datei definiert. Array enthält mehrere Zeichenfolgen. Jetzt muss ich eine Zeichenfolge bei einem bestimmten Index finden. Ich weiß nicht wie ich auf dieses Array von anderen Dateien zugreifen soll. Bitte beachten Sie meinen Code:

common.h

extern const char *lookup_str[] = {"test Str0", "test Str1", "test Str2", "test Str3"}; 

file1.cpp

int ret = 3; 
std::string r = lookup_str[ret]; 

Kann ich diese Art und Weise verwende in all meinen C-Dateien? Lassen Sie mich wissen, wenn Sie einen alternativen Ansatz sehen können. Jeder Vorschlag/Hilfe wird sehr geschätzt. Vielen Dank im Voraus !

Answer 1

Deklarieren Sie die Variable, ohne sie in der H-Datei Initialisierung:

extern const char *lookup_str[]; 

es initialisieren in genau einer Quelldatei.

const char *lookup_str[] = {"test Str0", "test Str1", "test Str2", "test Str3"}; 

Um es in einer CPP-Datei zu verwenden, verwenden:

#include "common.h" 

... 

int ret = 3; 
std::string r = lookup_str[ret]; 

---

Eine bessere Alternative, IMO, eine rein funktionale Schnittstelle zu den Daten zur Verfügung zu stellen wäre.

Die H-Datei:

std::string const& lookup_str(size_t index); 

Die CPP-Datei:

std::string const& lookup_str(size_t index) 
{ 
    static std::vector<std::string> str = {"test Str0", "test Str1", "test Str2", "test Str3"}; 
    return str.at(index); // This will throw exception if index is not 
          // within bounds. 
} 

und verwenden sie dann als:

#include "common.h" 

... 

size_t ret = 3; 
std::string r = lookup_str(ret); 

aktualisieren

A C++ 98 Implementierung von lookup_str() wäre:

std::string const& lookup_str(size_t index) 
{ 
    static std::vector<std::string> str; 
    if (str.empty()) 
    { 
     str.push_back("test Str0"); 
     str.push_back("test Str1"); 
     str.push_back("test Str2"); 
     str.push_back("test Str3"); 
    } 
    return str.at(index); 
} 

Answer 2

Sie vermeiden sollten Variablendefinitionen in Header-Dateien mit. Stattdessen können Sie eine Deklaration haben, die den Compiler einfach über ein Symbol informiert, das an anderer Stelle definiert und separat kompiliert werden kann.

extern const char *lookup_str[]; // defined elsewhere 

Und Sie sollten diese in der eine Quelle (.c) Datei (egal, welche man, solange es verknüpft ist in die endgültige ausführbaren Datei:

Also, Ihre Header sollten wie folgt aussehen):

const char *lookup_str[] = { ... }; 

Dann, es zu benutzen, einfach die oben genannten Header enthalten, und es wie jedes Array.

Answer 3

Da Sie dies in c++ tun, tun es nicht mit c-strings, tun es die C++ Art und Weise:

gemeinsam.cav

std::array<std::string, 4> lookup_str = {"test Str0", "test Str1", "test Str2", "test Str3"}; 

common.h

extern std::array<std::string, 4> lookup_str; 

Dann können Sie es auf die gleiche Weise verwenden:

int ret = 3; 
std::string r = lookup_str[ret]; 

Oder in ehrfürchtige C++ Möglichkeiten:

auto stringInArr = std::find(lookup_str.begin(), lookup_str.end(), "test Str3"); 

Hier

ist ein anschauliches Beispiel:

http://ideone.com/UFfIyV

Answer 4

Eine sauberere Design IMO wäre es, die extern und Definition in einer Header-Datei von Makrodefinition getrennt zu erklären

strdef.h

#ifdef STRING_INSTANCE_DEFINE 
const char *lookup_str[] = {"test Str0", "test Str1", "test Str2", "test Str3"}; 
#else 
extern const char *lookup_str[]; 
#endif 

strdef.c

#define STRING_INSTANCE_DEFINE 
#include <strdef.h> 

Alle anderen Dateien

#include <strdef.h> 

Remeber das Makro STRING_INSTANCE_DEFINE nur Datei in 1 .c zu definieren. Alle anderen Dateien, die das Array verwenden, könnten einfach die Header-Datei enthalten und wären für sie als extern verfügbar.