sirve - C++ para un desarrollador de C#

para que sirve c++

Question

Soy desarrollador .NET y trabajé con VB6 antes de eso. Me he familiarizado mucho con esos entornos y estoy trabajando en el contexto de los lenguajes recolectados. Sin embargo, ahora deseo reforzar mi conjunto de habilidades con C ++ nativo y encontrarme un poco abrumado. Irónicamente, no es lo que imagino que son los obstáculos habituales para los principiantes, ya que creo que tengo una buena comprensión de los indicadores y la gestión de la memoria. Lo que es un poco confuso para mí es más parecido a:

• Hacer referencia / usar otras bibliotecas
• Exponer mis bibliotecas para que otros las usen
• Manejo de cadenas
• Conversiones de tipo de datos
• Buena estructura de proyecto
• Estructuras de datos para usar (es decir, en C #, uso mucho List<T> , ¿qué uso en C ++ funciona de forma similar?)

Casi parece que dependiendo del IDE que uses, las pautas son diferentes, así que realmente estaba buscando algo que quizás sea un poco más universal. O en el peor, se centró en el uso del compilador / IDE de Microsoft. Además, para ser claros, no estoy buscando nada sobre las prácticas generales de programación (Patrones de diseño, Código completo, etc.) ya que creo que estoy bastante versado en esos temas.

Answer 1

La referencia y el uso de otras bibliotecas, si incluye la fuente, se lleva a cabo simplemente con #incluyendo los archivos de encabezado de la biblioteca en el archivo .cpp en el que los necesite (y luego compile el origen de la biblioteca junto con su proyecto). La mayoría de las veces, sin embargo, probablemente utilizará .lib (biblioteca estática) o .dll (biblioteca dinámica). La mayoría de las DLL (todas?) Vienen con un archivo .lib, por lo que el procedimiento para ambos tipos es el mismo: incluya los archivos de encabezado apropiados donde los necesite y luego agregue el archivo .lib asociado durante el paso de vinculación (en Visual Studio, I piense que puede simplemente agregar el archivo al proyecto).

Ha pasado mucho tiempo desde que creé mis propias bibliotecas para que otras las usen, así que dejaré que otra persona responda esa parte. O volveré y editaré esta respuesta mañana, ya que voy a tener que crear una .lib para trabajar mañana :)

Las cosas de cadena usualmente se logran con std :: string. En circunstancias especiales, también puede usar la antigua función sprintf () del estilo C, pero eso generalmente se desaconseja.

En cuanto a las estructuras de datos que está buscando, consulte la STL (Biblioteca de plantillas estándar). Incluye Lista, Vector, Mapa, Cadena, etc. que deberían serle familiares. No estoy seguro de lo que quiere decir con las conversiones de tipo ... Supongo que sabe sobre el casting, por lo que debe significar algo más complejo que eso, en cuyo caso es probable que sea específico para los tipos que intenta convertir. Tal vez alguien más puede ofrecer más información.

Answer 2

No voy a repetir lo que otros han dicho sobre las bibliotecas y demás, pero si te tomas en serio C ++, hazte un favor y elige "El lenguaje de programación en C ++" de Bjarne Stroustrup.

Me tomó años trabajar en C ++ para finalmente recoger una copia, y una vez que lo hice, pasé una tarde dándome palmadas en la frente diciendo "¡por supuesto! ¡Debería haberme dado cuenta!"

(Irónicamente, EXACTAMENTE tuve la misma experiencia con "The C Programming Language" de K & R. Algún día, aprenderé a obtener "The Book" el día 1.)

Answer 3

Tienes algunos kits de herramientas disponibles. Por ejemplo, hay STL (Biblioteca de plantillas estándar) y Boost / TR1 (extensiones para STL) que se consideran estándares de la industria (bueno, STL es, al menos). Estos proporcionan listas, mapas, conjuntos, punteros compartidos, cadenas, flujos y todo tipo de otras herramientas útiles. Lo mejor de todo es que son ampliamente compatibles con los compiladores.

En cuanto a las conversiones de datos, puede hacer conversiones o crear funciones de conversión explícitas.

Bibliotecas: puede crear bibliotecas estáticas (absorbidas en el ejecutable final) o DLL (ya está familiarizado con ellas). MSDN es un recurso increíble para archivos DLL. Las bibliotecas estáticas dependen de su entorno de compilación.

En general, este es mi consejo: - Conozca muy bien su IDE de elección - Compre "C ++ The Complete Reference" por Herbert Schildt, que considero que es un excelente tomo sobre todas las cosas C ++ (incluye STL)

Teniendo en cuenta tus antecedentes, deberías estar bien configurado una vez que hagas ambas cosas.

Answer 4

En respuesta a "Hacer referencia / usar otras bibliotecas"

La información sobre la carga explícita de DLL en C / C ++ para Windows y Linux incluye ...

Windows:

Tutorial de Windows DLL

Funciones: LoadLibrary, GetProcAddress, FreeLibrary

Linux:

Funciones: dlopen, dlsym, dlerror, dlclose

Tutorial DLL de Linux

Answer 5

Escribí una pequeña hoja de trucos para esos programadores. También podría estar interesado en casos más complicados, como varargs

Answer 6

Sé que dice que tiene una buena comprensión de los indicadores y la administración de la memoria, pero aún me gustaría explicar un truco importante. Como regla general, nunca tengas nuevo / eliminar en tu código de usuario.

Cada adquisición de recursos (ya sea un bloqueo de sincronización, una conexión de base de datos o una porción de memoria o cualquier otra cosa que deba adquirirse y liberarse) debe envolverse en un objeto para que el constructor realice la adquisición y el destructor libere el recurso. La técnica se conoce como RAII , y es básicamente la forma de evitar fugas de memoria. Acostumbrarse a él. La biblioteca estándar de C ++ obviamente usa esto extensivamente, para que pueda tener una idea de cómo funciona allí. Saltando un poco en sus preguntas, el equivalente de List<T> es std::vector<T> , y usa RAII para administrar su memoria. Lo usarías algo como esto:

void foo() {
// declare a vector *without* using new. We want it allocated on the stack, not
// the heap. The vector can allocate data on the heap if and when it feels like
// it internally. We just don''t need to see it in our user code
std::vector<int> v;
v.push_back(4);
v.push_back(42); // Add a few numbers to it
// And that is all. When we leave the scope of this function, the destructors
// of all local variables, in this case our vector, are called - regardless of
// *how* we leave the function. Even if an exception is thrown, v still goes
// out of scope, so its destructor is called, and it cleans up nicely. That''s
// also why C++ doesn''t have a finally clause for exception handling, but only
// try/catch. Anything that would otherwise go in the finally clause can be put
// in the destructor of a local object.
} 

Si tuviera que elegir un solo principio que un programador de C ++ debe aprender y adoptar, es el anterior. Deje que las reglas de alcance y los destructores trabajen para usted. Ofrecen todas las garantías que necesita para escribir código seguro.

Manejo de cadenas

std::string es tu amigo allí. En C, utilizaría matrices de char (o char punteros), pero esas son desagradables, porque no se comportan como cadenas. En C ++, tiene una clase std :: string, que se comporta como era de esperar. Lo único a tener en cuenta es que "hello world" es del tipo char [12] y NOT std :: string. (para la compatibilidad con C), por lo que a veces debe convertir explícitamente su cadena literal (algo entre comillas, como "hello world") a std :: string para obtener el comportamiento que desea: puede seguir escribiendo

std::string s = "hello world";

porque las cadenas tipo C (como literales, como "hello world") son implícitamente convertibles a std :: string, pero no siempre funciona: "hello" + "world" no se compilará, porque el operador + no está definido para dos punteros. "hola worl" + ''d'' sin embargo, se compilará, pero no hará nada sensato. En lugar de agregar un char a una cadena, tomará el valor integral de la char (que se promociona a una int) y lo sumará al valor del puntero.

std :: string ("hello worl") + "d" hace lo que cabría esperar, porque el lado izquierdo ya es std :: string, y el operador de suma está sobrecargado para que std :: string haga lo que lo esperaría, incluso cuando el lado derecho sea un char * o un solo carácter.

Una nota final sobre cadenas: std :: string usa char, que es un tipo de datos de un solo byte. Es decir, no es adecuado para texto unicode. C ++ proporciona el tipo de caracteres anchos wchar_t, que es de 2 o 4 bytes, dependiendo de la plataforma, y ​​se usa generalmente para texto unicode (aunque en ninguno de los casos el estándar C ++ realmente especifica el conjunto de caracteres). Y una cadena de wchar_t se llama std :: wstring.

Bibliotecas:

Ellos no existen, fundamentalmente. El lenguaje C ++ no tiene noción de bibliotecas, y esto lleva tiempo acostumbrarse. Le permite #incluir otro archivo (generalmente un archivo de encabezado con la extensión .h o .hpp), pero esto es simplemente una copia / pegado literal. El preprocesador simplemente combina los dos archivos que resultan en lo que se llama una unidad de traducción. Múltiples archivos de origen generalmente incluirán los mismos encabezados, y eso solo funciona bajo ciertas circunstancias específicas, por lo que este bit es clave para entender el modelo de compilación C ++, que es notoriamente peculiar. En lugar de compilar un grupo de módulos separados y exhanging algún tipo de metadatos entre ellos, como haría un compilador de C #, cada unidad de traducción se compila de forma aislada, y los archivos de objetos resultantes se pasan a un enlazador que luego intenta combinar los bits comunes de vuelta juntos (si varias unidades de traducción incluyeron el mismo encabezado, esencialmente tiene un código duplicado en las unidades de traducción, por lo que el enlazador las fusiona en una única definición);)

Por supuesto, hay formas específicas de plataforma para escribir bibliotecas. En Windows, puede hacer .dll o .libs, con la diferencia de que un .lib está vinculado a su aplicación, mientras que un .dll es un archivo separado que debe agrupar con su aplicación, como en .NET. En Linux, los tipos de archivos equivalentes son .so y .a, y en todos los casos, también debe proporcionar los archivos de encabezado relevantes para que las personas puedan desarrollar en contra de sus bibliotecas.

Conversiones de tipos de datos:

No estoy seguro de qué es exactamente lo que está buscando allí, pero un punto que creo que es significativo es que el reparto "tradicional", como el siguiente, es malo:

int i = (int)42.0f; 

Hay varias razones para esto. En primer lugar, intenta realizar varios tipos de moldes en orden, y es posible que se sorprenda de cuál termina el compilador. En segundo lugar, es difícil de encontrar en una búsqueda, y en tercer lugar, no es lo suficientemente feo. Los yesos generalmente se evitan mejor, y en C ++, se vuelven un poco feos para recordar esto. ;)

// The most common cast, when the types are known at compile-time. That is, if
// inheritance isn''t involved, this is generally the one to use
static_cast<U>(T);
// The equivalent for polymorphic types. Does the same as above, but performs a
// runtime typecheck to ensure that the cast is actually valid
dynamic_cast<U>(T);
// Is mainly used for converting pointer types. Basically, it says "don''t perform
// an actual conversion of the data (like from 42.0f to 42), but simply take the
// same bit pattern and reinterpret it as if it had been something else). It is
// usually not portable, and in fact, guarantees less than I just said.
reinterpret_cast<U>(T);
// For adding or removing const-ness. You can''t call a non-const member function
// of a const object, but with a const-cast you can remove the const-ness from
// the object. Generally a bad idea, but can be necessary.
const_cast<U>(T);

Como notará, estos moldes son mucho más específicos, lo que significa que el compilador puede darle un error si el molde no es válido (a diferencia de la sintaxis tradicional, donde simplemente probaría cualquiera de los moldes anteriores hasta que encuentre uno que funcione ), y es grande y detallado, lo que le permite buscarlo, y le recuerda que deben evitarse cuando sea posible. ;)

La biblioteca estándar:

Finalmente, volviendo a las estructuras de datos, haga un esfuerzo para comprender la biblioteca estándar. Es pequeño, pero increíblemente versátil, y una vez que aprenda a usarlo, estará en una posición mucho mejor.

La biblioteca estándar consta de varios bloques de construcción bastante distintos (la biblioteca se ha acumulado a lo largo del tiempo. Partes de esta se portaron desde C. La biblioteca de flujos de E / S se adopta desde un lugar, y se adoptan las clases de contenedor y sus funcionalidades asociadas de una biblioteca completamente diferente, y están diseñados notablemente diferentes. Estos últimos son parte de lo que a menudo se conoce como STL (Standard Template Library). Estrictamente hablando, ese es el nombre de la biblioteca que, ligeramente modificado, fue adoptado en el Biblioteca estándar de C ++.

El STL es clave para entender "C ++ moderno". Está compuesto por tres pilares, contenedores, iteradores y algoritmos. En pocas palabras, los contenedores exponen iteradores, y los algoritmos funcionan en pares de iteradores.

El siguiente ejemplo toma un vector de int, agrega 1 a cada elemento y lo copia a una lista enlazada, por ejemplo:

int add1(int i) { return i+1; } // The function we wish to apply
void foo() {
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5); // Add the numbers 1-5 to the vector
std::list<int> l;
// Transform is an algorithm which applies some transformation to every element
// in an iterator range, and stores the output to a separate iterator
std::transform (
v.begin(),
v.end(), // Get an iterator range spanning the entire vector
// Create a special iterator which, when you move it forward, adds a new
// element to the container it points to. The output will be assigned to this
std::back_inserter(l)
add1); // And finally, the function we wish to apply to each element
}

El estilo anterior requiere un poco de tiempo para acostumbrarse, pero es extremadamente poderoso y conciso. Como la función de transformación está modelada, puede aceptar cualquier tipo como entrada, siempre que se comporten como iteradores. Esto significa que la función se puede usar para combinar cualquier tipo de contenedores, o incluso flujos o cualquier otra cosa que pueda repetirse, siempre que el iterador esté diseñado para ser compatible con el STL. Tampoco tenemos que usar el par de inicio / finalización. En lugar del iterador final, podríamos haber pasado un apuntando al tercer elemento, y el algoritmo se habría detenido allí. O podríamos haber escrito iteradores personalizados que se saltaban todos los demás elementos, o cualquier otra cosa que quisiéramos. Lo anterior es un ejemplo básico de cada uno de los tres pilares. Usamos un contenedor para almacenar nuestros datos, pero el algoritmo que usamos para procesarlo en realidad no tiene que saber sobre el contenedor. Solo tiene que saber sobre el rango del iterador en el que tiene que funcionar. Y, por supuesto, cada uno de estos tres pilares se puede ampliar al escribir nuevas clases, que luego funcionarán sin problemas junto con el resto del STL.

En cierto sentido, esto es muy similar a LINQ, así que como vienes de .NET, probablemente puedas ver algunas analogías. Sin embargo, la contraparte de STL es un poco más flexible, a costa de una sintaxis un poco más extraña. :) (Como se menciona en los comentarios, también es más eficiente. En general, no hay sobrecarga para los algoritmos STL, pueden ser tan eficientes como los bucles codificados a mano. Esto a menudo es sorprendente, pero es posible porque todos los tipos relevantes son conocido en tiempo de compilación (que es un requisito para que las plantillas funcionen), y los compiladores de C ++ tienden a alinearse agresivamente).