Usando C++ y MFC. Viniendo de un C# telón de fondo, normalmente solo uso de cadenas para todos, así, las cadenas de caracteres. Yo los uso para los miembros de la clase, los parámetros del método, y el método de valores de retorno.

Ahora en C++ tengo std::string, CString, char *, LPCTSTR, y más. Como puedo diseñar mis datos miembros, de los parámetros del método, y el método de devolución de los valores que tipo(s) debo utilizar? La facilidad de uso es importante y CString parece ofrecer eso, pero mi instinto me dice que es hacia portátil normas pesar de que la portabilidad es bastante bajo en mi lista de prioridades (ahora). Además, no me gusta el c semántica de la creación de búferes de cadena y se les pasa a los métodos y funciones.

Creo que a partir de una inmediata facilidad de codificación de la perspectiva de los objetos cstring probablemente tienen el borde. Pero, en general, ¿cuál es la «alta calidad del código» manera de hacer esto?

EDICIÓN:

Estoy especialmente preocupado por la interfaz de puntos en mi código (es decir, método de parámetros y valores de retorno). E. g.:

Shape::SetCaption(const char *caption) {...}

Shape::SetCaption(CString caption) {...}

Shape::SetCaption(std::string caption) {...}

Shape::SetCaption(std::wstring caption) {...}
  • Escribir un plugin para una plataforma que se implementa en MFC y debe integrarse perfectamente con ella. He probado a ir por la ruta de Qt, pero Qt/MFC integración fue una batalla cuesta arriba. Si se tratara de una opción que yo elegiría C#.
  • De acuerdo con Christian Rau comentario. MFC no es un programador marco favorable. QT es la forma de hacer GUI más simple.
InformationsquelleAutor User | 2011-05-24

4 Comentarios

  1. 19

    Por lo general prefieren adaptar mi estilo de codificación para el marco en el que estoy trabajando en ser consecuente con ella. Así que cuando yo trabajo con MFC (que no tengo por un largo tiempo), yo prefiero el uso de CString (y LPCTSTR como argumentos de la función pública los métodos de interfaz). Cuando se trabaja con Qt prefiero QString y Qt contenedores más contenedores STL y para todo lo no relacionado directamente con ese marco yo uso std::string como es el estándar de C++ forma de manipulación de cadenas.

    No hacer una gran diferencia, ya que todos ofrecen más o menos igual funcionalidad (y son fácilmente convertibles en cada uno de los otros) y cuando el código está escrito para un marco determinado, depende de todos modos, así que la portabilidad no es una gran preocupación.

    Simplemente no se molestan con la llanura char matrices! Y por el camino, trate de pasar objetos por referencia const (const std::string &caption) y no por su valor, como en C++ las variables no son automáticamente las referencias y la copia de una cadena que puede llegar a ser muy caro.

    • Yo a veces uso la llanura char matrices cuando necesito un buffer temporal para algo, aunque yo he tenido buena suerte con vector<char> demasiado.
    • Tiene sentido, pero se debe utilizar el objeto CString incluso en una biblioteca estática que construir para ser utilizado por un proyecto MFC?
    • Si la biblioteca no se utilizan o dependen de MFC y posiblemente podría ser utilizado con otro proyecto, definitivamente no. Pero si está vinculada a su proyecto de todos modos, no estoy muy seguro. Me gustaría utilizar std::string en todo lo que no es directamente relacionado a MFC para una mejor reutilización de código y la flexibilidad.
  2. 7

    MFC fue escrito con la expectativa de que tendría que utilizar CString. Esto es especialmente evidente cuando una función se utiliza un parámetro para devolver una cadena. Por ejemplo, compare estas dos llamadas a GetWindowText:

    CString s1;
    wnd.GetWindowText(s1);
    
    std::wstring s2(SOME_MAX, 0);
    int len = wnd.GetWindowText(&s2[0], s2.size());
    s2.resize(len);

    La conversión entre los dos no es malo, aunque, por lo que podría poner en peligro al usar std::wstring para la mayoría de las cosas, y una CString temporal cuando sea necesario.

    CString s3 = s2.c_str();
    std::wstring s4 = s1;

    Edición: puede ser una manera de automatizar el CString temporal. Feria de advertencia, este es un hack. No he probado este, así que no hay garantías de que probablemente advertencias acerca de la unión temporal a un no-const de referencia, pero se puede girar a la de los de fuera.

    class PopString : public CString
    {
    public:
        PopString(std::wstring & final) : m_final(final)
        {
        }
    
        ~PopString()
        {
            m_final = (PCTSTR) *this;
        }
    private:
        PopString(const PopString &) {}  //private copy constructor to prevent copying
        PopString & operator=(const PopString &) {}  //private copy operator
    
        std::wstring & m_final;
    };
    
    std::wstring s5;
    wnd.GetWindowText(PopString(s5));
  3. 3

    Si usted se preocupa por su portabilidad y utilizando C++ uso std::string. No hay punto de ir de bajo nivel con char matrices, si no es necesario. Si no te importa para la portabilidad y la plataforma proporcionada cadenas de proporcionar más de las características que usted necesita, por todos los medios, el uso de ellos. Que en realidad podrían ser más optimizado para la plataforma.

    • Técnicamente, el uso de std::basic_string<>, no sólo std::string. I. e., en Windows es mucho más probable que std::wstring es deseado.
    • ¿vas a decir std::basic_string<TCHAR>?
    • No, me refería a la std::basic_string<> plantilla de clase como un todo, frente a la std::basic_string<char> especialización (un.k.una. std::string) específicamente.
    • «Portable» + «mfc» = oxímoron
  4. 3

    No utilice CString. Utiliza una VACA aplicación que es muy vulnerable a las cosas como las operaciones de roscado. No utilice char* o LPCTSTR (que es sólo const char* o const wchar_t* bajo un nombre diferente), ya que no administren su propia memoria. El uso de un std::string de 8 bits puntos de codificación o std::wstring de 16 bits puntos de codificación en Windows (32 bits para Unix).

    • Es LPCTSTR, y char const* o wchar_t const* respectivamente.
    • No es como std cadena es seguro para subprocesos. Pero -1 debido al uso de mfc CString suele ser la manera de ir.
    • Dibling: std::string es thread-safe de una manera que CString no lo es. Si usted tiene dos independientes std::string, usted puede garantizar que son seguros para usar en dos hilos. No puede decirse lo mismo de CString.
    • Pensé, eso es lo que no puede garantizar, como STL ejecutores son de libre uso implícito de intercambio de cadenas de caracteres. Pero he escuchado el nuevo C++0x estándar quita esa libertad y por lo tanto se garantiza realmente threadsafe std::strings.
    • El problema es que solo se fija oficialmente, en la norma, como la de C++11, pero el problema fue formalmente reconocido en el Informe de Defecto 530 hace más de cinco años y ha sido implementado en cada una de las principales de la biblioteca estándar de aplicación desde luego (si no antes).
    • Sí – el Estándar sólo ha prohibido, pero nadie lo hizo antes, a continuación, de todos modos. Justo como técnicamente, std::string no tener memoria continua, pero en realidad casi todos en la aplicación.
    • Hay un enlace a un artículo o ASÍ, pregunta que 2 instancias de un objeto CString no puede ser utilizado de forma independiente en diferentes hilos? Suena bastante grave si este es realmente el caso. Es una especie de caso especial, o es en general el caso? Voy a estar usando VS 6.0. Hay una versión más reciente de VS que corrige el problema?
    • Que puede ser utilizado de forma independiente en diferentes hilos, pero son increíblemente lento mientras lo hace. Pero, si usted está usando VS 6.0, a continuación, usted tiene mayores problemas. Como el hecho de que el compilador no puede generar el código correcto para salvar su vida. O aceptar cualquier cosa, como la correcta C++.
    • Estoy de acuerdo con esta respuesta, a excepción de no molestarse siquiera con std::wstring. Siempre usar std::string. Si desea unicode, std::string puede ser tratada como UTF-8 (ver utf8everywhere.org).
    • El roscado reglas son explícitamente enunciados. Si eso no es suficiente para usted, implementar sincronización personalizada, o el uso de una cadena diferente de la clase. Con código de MFC casi siempre es mejor ir con CString‘s. Aún más, si usted está usando COM así. También voy a suponer que todas las apariciones de «puntos de codificación» debe leer «unidades de código». Tal vez al menos puede arreglar eso.
    • CString tiene otro implementación de std::stiring. Ahorra memoria y mejora de un único subproceso rendimiento a costa de un peor multiproceso rendimiento. Que es un buen cambio para un único subproceso de interfaz gráfica de usuario. Y no tienen esta std::string(nullptr) -> la excepción de mierda, por ejemplo. Así CString vs std::string elección depende de sus necesidades y limitaciones.

Dejar respuesta

Please enter your comment!
Please enter your name here