SoloCodigo

La idea basica es contar las transiciones de "espacio blanco" a "espacio no blanco".

Hola,

El nombre de los constructores debe ser el de la clase:

    public CocheSimple()
    {
        this.Marca = "sin marca";
        this.Modelo = "Sin modelo";
        this.VelMax = 0;
    }

    public CocheSimple(string marca, string modelo, int velmax)
    {
        this.Marca = marca;
        this.Modelo = modelo;
        this.VelMax = velmax;
    }

Otro tip:

Incluye la unidad en el nombre de variables numéricas:

private int VelMaxKmH;

Cuanto menos ambiguo sea el programa mucho mejor.

Me parece que esta tratando de acceder al objeto que guarda la imagen "cmd.ExecuteNonQuery()" cuando dicho objeto ya no está disponible.

Trata metiendo esto:
con.Open();
cmd.ExecuteNonQuery();


Dentro de:
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
...
}


Revisando la documentación de la clase CString de la MFC, encontré que está permitido hacer el casting: (LPCTSTR)nu
http://msdn.microsoft.com/en-us/library/awkwbzyc.aspx

Sin embargo no deberías hacer esto: (LPTSTR)nu ni esto: (TCHAR*)nu por que implica que vas a modificar los datos apuntados.

Esto debería funcionar sin necesidad de quitar el "const" al tipo apuntado.

wcstombs(aux, (LPCTSTR)nu, nu.GetLength() + 1);

Nota: asumiendo que TCHAR está definido como wchar_t y no como char.

Los íconos hechos por profesionales de diseño gráfico vienen en variedad de tamaños. Muestra el que tenga tamaño adecuado.

El problema de esas pequeñas optimizaciones es que su velocidad depende mucho del contexto (las instrucciones que le preceden y suceden, el estado de la memoria, el estado del caché, etc, etc.). También depende del compilador que uses (que instrucciones genera y si está optimizado para cierto tipo de procesadores), de la arquitectura del procesador y hasta del modelo del procesador. Al final no tienes la certeza si el código será una nada más rápido o una nada más lento, a menos que midas el rendimiento varias veces con una muestra representativa del tipo de datos que serán procesados y saques un promedio para compararlos objetivamente.

Lo que si da resultados, independientes de otros factores, es reducir la complejidad matemática del algoritmo.

Para almacenar la suma en "vector" basta sobrecargar el constructor copia de "vector" para poder recibir const matrix&. Además tienes que agregar un constructor sin párametros "default constructor" para "matrix" y también es buena idea si las clases hijas tienen uno.

Supongo que todo esto es simple ejercicio académico, por que es un poco absurdo tener esas dos clases hijas, puesto que tienen el mismo comportamiento y miembros de la clase padre.

De acuerdo con todo, especialmente con adoptar un estilo definido de programación.

Aunque personalmente prefiero este tipo de comparaciones para verificar punteros no nulos:

Y para los nulos prefiero usar el 0, ¿Para que escribir 4 letras y ocultar lo que en realidad es un puntero nulo?

Tampoco me hago problema con un if en una sóla linea siempre y cuando sea más rápido de leer. En casos extremadamente simples es más rápido leer esto:

que esto:

El nombre que aparece es el que está guardado en el MSI de cada parche. Lo que puedes hacer es usar ORCA para cambiar en la tabla "Property" el valor de "ProductName" en cada MSI.  El instalador de ORCA viene con el SDK de visual studio.

Otra forma es tomar ventaja que las salidas están secuencialmente correlacionadas a las entradas. Si conoces el código ASCII sabes que cada letra está asociada a un número: 'A' es 65, 'B' 66 y así sucesivamente para las letras del alfabeto inglés. Si c es una variable de tipo char entonces c - 64 devolverá el resultado esperado.

Si crees que ese código "está bien" entonces estas muy confundido en el tema de punteros. Primero tienes que desechar todo lo que crees saber de punteros y empezar desde 0.

Algunos errores:

1. No inicializaste los punteros a 0. Simplemente imperdonable.
2. Como el nombre de tipo que escogiste para "Pila" es malísimo definiste un doble puntero donde sólo era necesario un simple puntero, tal vez por accidente.
3. En lugar de pasar la dirección del puntero a push y pop, le pasas el valor apuntado. Seguro que no compila por que la función espera un doble puntero.

Deberías pasar los parámetros por referencia, una gran ventaja de C++ para mejorar la legibilidad de tu código. También puede ayudar mucho adoptar un estilo de programación para darles nombres apropiados a los tipos.



Esta es la versión usando clases, incluye constructor copia y operador de asignación. El operador new (std::nothrow) permite que la función push retorne falso si no existe suficiente memoria.

Con char* también estás reservando y liberando memoria.

"char*" es sólo un puntero, no implica reservar ni liberar memoria. El ejemplo que puse tampoco reserva ni libera memoria directamente por que es la clase std::string la que reserva y libera la cantidad de memoria necesaria.

Mezclar C y C++ para un ejemplo pequeño no hay problema. Mezcla C y C++ en un proyecto grande y luego venid llorando.

Para nada, nunca he tenido ese problema. Lo que si es problema es que los programadores digan que saben C++ cuando no tienen idea de POO, o cuando dicen que saben C y creen que la memoria se libera mágicamente o te llenan el código de posibles "buffer overflow". O cuando no se toman el tiempo suficiente para leer la documentación de las bibliotecas que van a usar y te llenan el código de "leaks". También están los que no pueden vivir sin abusar de los patrones de diseño y para colmo los implementan mal. Etc, etc, etc. Pero mezclar C con C++ nunca ha sido problema.  

Bueno estas son las ventajas de usar const char* :

1. Es mucho más rápido que usar el operador[] de std::string. (Usando un desensamblador (rodeando el código con instrucciones asm que nunca encontrarías en un programa normal ) es posible ubicar el código generado y tener una buena idea de la diferencia.)
2. No tienes que crear una instancia de std::string para llamar a esa función. Es decir si no tenías un objeto std::string de antemano. Reservar y liberar memoria para una instancia temporal es mucho castigo para la eficiencia de cualquier aplicación.
3. No tienes que incluir <string>, como ya dijeron no es necesario conocer esa clase para poder entender el código.

No es que tenga algo en contra de std::string, todo lo contrario, por que detesto reservar y liberar memoria en C todo el tiempo hasta para una simple cadena. Pero si tengo chance de tomar lo mejor de c++ y c, pues lo hago.