Traduction de chaînes const dans les initialiseurs de structure

Question

Je travaille avec une base de code importante qui utilise des chaînes const dans les initialiseurs de structure. J'essaye de traduire ces chaînes via GNU gettext avec un minimum de temps. Existe-t-il une sorte d'opérateur de conversion que je peux ajouter à default_value, ce qui permettra au cas n ° 1 de fonctionner?

#include <cstring> 

template<int N> struct fixed_string 
{ 
    char text[N]; 
}; 

// Case #1 
struct data1 
{ 
    char string[50]; 
}; 

// Case #2 
struct data2 
{ 
    const char* string; 
}; 

// Case #3 
struct data3 
{ 
    fixed_string<50> string; 
}; 

// A conversion helper 
struct default_value 
{ 
    const char* text; 
    default_value(const char* t): text(t) {} 

    operator const char*() const 
    { 
     return text; 
    } 

    template<int M> operator fixed_string<M>() const 
    { 
     fixed_string<M> ret; 
     std::strncpy(ret.text, text, M); 
     ret.text[M - 1] = 0; 
     return ret; 
    } 
}; 

// The translation function 
const char* translate(const char* text) {return "TheTranslation";} 

int main() 
{ 
    data1 d1 = {default_value(translate("Hello"))}; // Broken 
    data2 d2 = {default_value(translate("Hello"))}; // Works 
    data3 d3 = {default_value(translate("Hello"))}; // Works 
} 

Answer 1

Qu'en est-il de la conversion directe en données1?

.. 
operator data1() const 
{ 
    data1 ret; 
    std::strncpy(ret.string, text, sizeof(ret.string)); 
    ret.string[sizeof(ret.string)] = 0; 
    return ret; 
} 
.. 

puis:

.. 
    data1 d1 = default_value(translate("Hello")); // should work now... 
..