Mensajes

Ve a windows, botón derecho en el escritorio, propiedades, te vas a monitor, y ahí anotas la resolución y la frecuencia.

Te vuelves a linux y lanzas desde la consola el cvt con esa resolución y esa frecuencia.

cvt resolución frecuencia

y anotas qué sale.

Visual studio 2010 express es un IDE (Entorno de Desarrollo Integrado) que trae entre otras cosas el compilador Visual C++ 2010 de Microsoft. Lo que quizá tu profesor quiera es que usando visual studio tengas mayor facilidad a la hora de utilizar librerías de windows. Eso no lo se.

En principio, si ya tienes algo instalado, y lo otro no supone una gran mejora no veo por qué haya que cambiar, salvo que exista alguna razón en concreto, como por ejemplo el debugger de Visual Studio.

Eso lo tendrías que hablar ya con tu profesor.

Por otro lado, si aprendes C++ estándar, en teoría debería dar igual si lo haces en Visual Studio, en Code::Blocks, en Eclipse con el plugin CDT o usando emacs y compilando con g++ (compilador de C++ de gcc). El problema está cuando, por ejemplo, aprendes en base a usar librerías de windows o de linux mientras aprendes C++ (véase el uso de conio como caso ejemplo de ello)

Libro... el que utilizo como referencia es:

C++ estándar (Programación con el estándar ISO y la Biblioteca de Plantillas (STL))
Enrique Hernández Orallo, José Hernandez Orallo, Mª Carmen Juan Lizandra
Paraninfo - Thomson Learning
ISBN: 84-9732-040-9

(daría un enlace para descargarlo, pero no he encontrado, la vez que busqué, algún pdf o similar con el libro)

Por otro lado, Littlehorse (moderador del subforo) suele recomendar uno que hay colgado en este post: http://foro.elhacker.net/programacion_cc/librospapers_cc-t296234.0.html

Name: Cómo Programar en C/C++
Author(s): Harvey M. Deitel, Paul J. Deitel
Hardcover: 1072 pages
Publisher: Prentice Hall; 2nd edition (February 1998)
ISBN-10: 9688804711
ISBN-13: 978-9688804711

(hay un enlace para descargarlo)

Yo utilizo el de C++ estándar porque me gustó cuando me lo recomendó un profesor en la facultad y lo saqué una temporada de la bilioteca y al final me lo terminé comprando. Sobre el de Deitel & Deitel, no tengo mayor referencia que el hecho que Littlehorse lo recomiende. (Si vas a buscar el de Deitel & Deitel, intenta buscar una edición más actual, que imagino que la habrá)

Exacto, si tu lees una cadena, y quieres comprobar si es un número, tienes que comprobar que todos sus dígitos sean números.

Ejemplo:

te introducen 65536 y lo lees como cadena de caracteres , el contenido de dicha cadena es:

Código (cpp) [Seleccionar] Expandir


cad[0]='6'
cad[1]='5'
cad[2]='5'
cad[3]='3'
cad[4]='6'
cad[5]='\0'

mientras, que si tu lo lees como un entero, simplemente es un entero que tiene el valor 65536.

Si tu estás leyendo números como cadenas, y te preocupa que te puedan colar cosas como asd345:
representado como:

Código (cpp) [Seleccionar] Expandir


cad[0]='a'
cad[1]='s'
cad[2]='d'
cad[3]='3'
cad[4]='4'
cad[5]='5'
cad[6]='\0'
Utilizas isdigit para cada carácter o lo que he comentado yo antes.

Creo que antes no me he podido expresar mejor, te conviene revisar qué hace isdigit, y añado, qué clase de caracteres se encuentran en la tabla ASCII, porque isdigit solo te dice si pertenece a un tipo o no.

Tu problema (o uno de ellos):

Código (cpp) [Seleccionar] Expandir

for(int i=0;i<strlen(sub_cadena);i++)  
   {
        if(isdigit(sub_cadena[i])!=0)
        {
         x++;
        }
         if(isdigit(sub_cadena[i])==0)
        {
         x++;
        }
    }

Si es un numero, incrementas x, sino, también, boom goes the dynamite.
De esta forma, directamente recorres la cadena llamando a isdigit 2 veces por cada carácter y ya, sin diferenciar si es una letra, un numero, o un signo de puntuación, o cualquier otro carácter especial.

Creo que aquí prefieras usar isalnum

Por otro lado: las cadenas, las introduces como (ejemplo) "asd53" o como asd53 ? porque si es el segundo caso, problema.

Además, te repito, tu código comprueba los 4 casos (caden,a entero, float, identificador) SIEMPRE, y eso no es muy eficiente. Si ya has visto que es una cadena, por ejemplo, para qué hacer el resto?

isdigit sólo te mira un carácter, si quieres comprobar toda una cadena, lo lanzas n veces para toda la cadena.

Otra opción, es comparar si el carácter en el que estás (mientras recorres la cadena) está entre el valor del carácter 0 y el valor del carácter 9

Código (cpp) [Seleccionar] Expandir

caracter>='0' && caracter<='9' Que imagino será lo que isdigit hace por debajo, pero de esta forma, te ahorras llamar a una función

ctv resolución_que_tuvieses_en_windows frecuencia_que_tuvieses_en_windows

Porque si tu usas el ctv de esta forma:

ctv 1024x768 60

y con ello, sacas, pongamos 51.40 Hz, es que ya tienes ambos valores. Le has dicho que quieres que te diga el primero en función del segundo, es decir, el 51.40 te lo saca según el 60, no necesitas sacarlo tu.

Has probado a usar ahora lo que dice en la última parte del post que te pasé? usar el cvt para encontrar los valores de refresco y demás?

No hay ninguna diferencia, lo que haces con un #define es declarar constantes. Ahora, esas constantes pueden ser un valor o una expresión.

ERROR Si la hay, y es ENORME.

define: lo que esté despues de, por así decirlo, la etiqueta, se EMPOTRA directamente en el código, por el preprocesador, no se hace comprobación de tipos ni nada por el estilo, simplemente se sustituye, y ya.
Ejemplo:

Código (cpp) [Seleccionar] Expandir


#define cuadrado((a)) (a)*(a)
con el siguiente ejemplo:

Código (cpp) [Seleccionar] Expandir


i=4;
cuadrado(i++)

Resultado? 16, si, valor de la i=5? NO i=6. ¿WTF? Pensarán algunos.

Porque el preprocesador lo sustituye como:

Código (cpp) [Seleccionar] Expandir

i=4
(i++)*(i++)

Y por precedencia de operadores, se realiza la multiplicación, y luego los post-incrementos

Por otro lado, un define NO ocupa más memoria que la que ocupe el código definido y dicha memoria será ocupada en el espacio dedicado a código, mientras que una constante, es una variable, y que por tanto, ocupará su espacio en el segmento de memoria dedicado a variables.


Por otro lado, utilizando el ejemplo del cuadrado, mirad que pasa si hacéis esto:

Código (cpp) [Seleccionar] Expandir


cuadrado(cuadrado(i)*cuadrado(i))

Lo ideal sería suponer una implementación de este estilo:

Código (cpp) [Seleccionar] Expandir


res1=resultado_cuadrado(i)*resultado_cuadrado(i)
cuadrado(res1)

Pero, con los defines, al tratarse de código empotrado, se traduce como(es posible que me deje algo, pero básicamente es un infierno de calculo):

Código (cpp) [Seleccionar] Expandir

((i*i)*(i*i))*((i*i)*(i*i))

Por qué? Porque primero, traduce el cuadrado de i en i*i, y luego, la multiplicación de cuadrados en (i*i)*(i*i) PERO como luego eso se lo pasamos como "argumento", y nuestro define, coge dicho argumento y lo multiplica por si mismo, tenemos la tira infernal de arriba.

Los defines (macros) son peligrosos.