Esto lo digo porque hay personas que parece no interesarles que un programa es algo que en algún momento tiene que "aterrizar" en una computadora concreta.
No conozco el VirtualBox.
Pero si se pudiera correr Linux dentro de VirtualBox bajo Windows, podría intentar llevar adelante el curso también para Linux.
Bueno muchachos, voy a tratar de ir comprobando todas estas opciones para Linux, a ver qué conviene más.
Por ahora lo que me preocupa es que los programitas que habrá en el curso son para la línea de comandos de Windows, o sea que carga la ventanita fea de CMD.
Estoy buscando alguna alternativa.
También se puede hacer algún programita con los mínimos requerimientos para generar una ventana básica en Windows, pero quisiera evitar esto en lo posible.
Bueno muchachos, voy a tratar de ir comprobando todas estas opciones para Linux, a ver qué conviene más.
Por ahora lo que me preocupa es que los programitas que habrá en el curso son para la línea de comandos de Windows, o sea que carga la ventanita fea de CMD.
Estoy buscando alguna alternativa.
También se puede hacer algún programita con los mínimos requerimientos para generar una ventana básica en Windows, pero quisiera evitar esto en lo posible.
Pero si es por el color negro, el tamaño de letra, etc., eso se puede cambiar en esa ventana pinchando en la esquina izquierda de arriba (o con le botón derecho del ratón en cualquier parte de la barra de arriba) se abre una lista en la cual una de las opciones es "propiedades", y ahí puedes redimensionarla a gusto, cambiar el color de fondo, el de letra, el tamaño de la fuente...
Hummm. Tu consejo no sirve, porque cuando ejecuto el programa compilado en DevC++ se pierde la configuración hecha al CMD en "Propiedades".
Hummm. Tu consejo no sirve, porque cuando ejecuto el programa compilado en DevC++ se pierde la configuración hecha al CMD en "Propiedades".
:'( :'( :'( :'(
Sí, si se conserva el nombre de archivo si se ha marcado previamente la casilla "Guardar propiedades para todas las ventanas con el mismo título" antes de "Aceptar" propiedades; aunque lo modifiques y lo recompiles. Ahora bien, cada vez que haces un ejecutable con otro nombre, entonces, sí, hay que configurar, la primera vez al ejecutarlo, las propiedades
Saludos.
Igual no importa, porque gracias a esto me estuve divirtiendo con las directivas del compilador:
http://rinconmatematico.com/foros/index.php?topic=64835.msg260354#msg260354 (http://rinconmatematico.com/foros/index.php?topic=64835.msg260354#msg260354)
Sin embargo, por lo que veo por tus dudas, es menos intuitivo, ya que la comparación no se hace IN SITU, sino antes, y no se ve claramente que estamos interesados en el resultado de dicha comparación.
Es esto #define (Creo_que) (Me_Gusta_mas_Windows) Es decir, carga el valor de
Es esto #define (Creo_que) (Me_Gusta_mas_Windows) Es decir, carga el valor de
Eso así está mal, no se le pone un paréntesis al primer identificador "Creo_que".
En cambio está bien, y es aconsejable hacerlo, con el segundo, así:
#define Creo_que (Me_Gusta_mas_Windows)
Y sí, es lo que vos decís.
No me dí cuenta que se podía ver todo muy "pegoteado".
Claro, la función del los guiones bajos es esa.
Hay gente que ni los usa, y pone mayúsculas para indicar nueva palabra, así:
CreoQue
En cuanto a la terminología adecuada... no es ni variables, ni constante a mano, jejeje.
Yo diría que hay que usar el término "identificador".
Las "constantes a mano" no son identificadores, porque no son nombres de nada,
sino que son valores explícitos de algún tipo, ya sea números, caracteres, cadenas de caracteres, etc.
Comprendo, #define viene a ser parecida a al comando "def fn" del antiguo Basic.
Estas tareas de gestión es necesario comprenderlas, aunque sea de a poco.
He puesto estos ejercicios a propósito para aprender estas cosas.
[
Ya, me doy cuenta de ello, las sentencias que no cumplen los condicionales no son compiladas, ¿es eso lo que quieres decir?
Ahora bien, supongamos que pusieras una sentencia tipo "input" asociada a los "if", que esperase que el usuario introdujese un valor para tomar un camino u otro; en ese caso habrá que añadir un bucle que vuelva al "input" constantemente en espera de nuestra entrada, pero a la vez tendrá que dejar de compilar, imagino, para seguir compilando a partir de nuestra orden un trozo de programa u otro, ¿no?
No puede haber interacción con el usuario, porque no se mezclan las etapas de compilación con las del programa ya ejecutable.
MMmmm... No sé.
Creo que estoy complicando demasiado el asunto con tan sólo el "Hola Mundo" y sus amigos.
>:D
MMmmm... No sé.
Creo que estoy complicando demasiado el asunto con tan sólo el "Hola Mundo" y sus amigos.
>:D
No te preocupes, no lo complicas, es complicado, :D que es distinto.
Según he consultado en Internet por ahí, parece ser que durante la compilación sí se pasa a código en números binarios y después se ensambla inmediatamente; ahora bien, no he podido enterarme si eso de "ensamblar" ser refiere al código código ensamblador de antes, del que yo sí conocía un poco básicamente, o es otra cosa.
De todas formas, tú ve a tu aire, que yo te sigo como pueda y ya con la práctica me iré enterando. Además, parece que tiene cosas bastante parecidas al Javascript en cuanto a declaración de variables locales y algunas cosas así que conozco también de forma básica (de hacer tonterías con el Flash Macromedia).
Saludos y gracias.
Una curiosidad que yo no sabía, fíjate lo que dice aquí:
(es un fragmento de lo que viene en este enlace) http://es.wikipedia.org/wiki/Lenguaje_ensamblador
"Los programas hechos por un programador experto en lenguaje ensamblador son generalmente mucho más rápidos y consumen menos recursos del sistema (memoria RAM y ROM) que el programa equivalente compilado desde un lenguaje de alto nivel. Al programar cuidadosamente en lenguaje ensamblador se pueden crear programas que se ejecutan más rápidamente y ocupan menos espacio que con lenguajes de alto nivel."
Es decir, que los compiladores son menos perfectos que los seres humanos a la hora de ahorrar espacio y hacer que un programa funcione más deprisa :o
Assembly language
A program written in assembly language consists of a series of (mnemonic) processor instructions and meta-statements (known variously as directives, pseudo-instructions and pseudo-ops), comments and data. Assembly language instructions usually consist of an opcode mnemonic followed by a list of data, arguments or parameters.[4] These are translated by an assembler into machine language instructions that can be loaded into memory and executed.
Compilar en C da programas más eficientes y rápidos que con otros lenguajes.
Aunque igual algo podemos llegar a hacer... ::)
Tendrías que colgar acá tu programa, si querés que entienda el problema.
El tipo de datos básico asociado en C a las strings es char*.
Otro día les explico qué es ese asterisco: *. ::)
El tipo de datos básico asociado en C a las strings es char*.
Otro día les explico qué es ese asterisco: *. ::)
Estoy ansioso de que llegue ese día :laugh:.
No sirve de nada que copie un programa de ese video de Youtube, porque el programa que tiene errores es el tuyo.
Por eso tengo que ver tu programa.
Además, aunque el programa del video es corto, no lo pienso copiar a mano, porque encima lo va cambiando durante todo el video, y tengo que comerme toda la explicación hasta ver qué diablos es lo que hace.
No voy a mirar videos...
No sirve de nada que copie un programa de ese video de Youtube, porque el programa que tiene errores es el tuyo.
Por eso tengo que ver tu programa.
Además, aunque el programa del video es corto, no lo pienso copiar a mano, porque encima lo va cambiando durante todo el video, y tengo que comerme toda la explicación hasta ver qué diablos es lo que hace.
No voy a mirar videos...
Bueno, hombre, no te pongas así :laugh: :laugh: Decía sólo la primera parte hasta que ejecuta; lo he mirado y remirado, repasado puntos y comas, etc., pero introduzco el número y ahí se queda, el condicional que le sigue no corre. Pero da igual, ya lo repaso más veces, a ver...
Me puse celoso, me andás engañando con el tipo ese de youtube. :'(
Me estoy divirtiendo con el asunto de cómo se especifican las constantes en C, ya sea char o int, y cuáles son todas las vicisitudes en torno a la asignación de tipos de datos a esas constantes.
Es algo terriblemente complicado, pero me dí el gusto de hallar toda la información, sacar las conclusiones, y analizar todos los detalles. >:(
Esto hay que hacerlo alguna vez, porque si no, después vienen las sorpresas, y nadie entiende por qué el programa puso un número donde uno esperaba que ponga otro...
Sí, cuando dije que estaba ansioso por ver como tratarías todo el tema de los punteros y la memoria dinámica no lo dije como si toda esta introducción me aburriera;
Además de esa forma se puede investigar sobre cómo representa C cada tipo de datos.
se puede investigar sobre cómo representa C cada tipo de datos.
Ya que estás con la representación interna de los distintos tipos de datos, como sugerencia nada más, podrías explicar algo sobre las máscaras de bits en C y en general sobre los operadores bit a bit.
#include <stdio.h>
int main(){
int k,n;
n=-2;
for(k=31; k>=0; k=k-1)
printf("%d",(n & (1 << k)) >> k);
return 0;
}
y muestra:
-11111111111111111111111111111110
>> Corrimiento a derecha:
El patrón de bits de expr-desplazada sufre un desplazamiento derecho del valor indicado por la expr-desplazamiento. Como en el caso anterior, ambos operandos deben ser números enteros o enumeraciones. En caso contrario, el compilador realiza una conversión automática de tipo. El resultado es del tipo del primer operando.
Una vez promovida a entero, expr-desplazamiento debe ser un entero positivo y menor que la longitud del primer operando. En caso contrario, el resultado es indefinido (depende de la implementación).
Nota: en C++Builder y GNU-C++, el signo se mantiene, lo que significa que el desplazamiento se realiza contando con el signo, el nuevo bit más significativo será 0 si se trata de un número positivo y 1 si el número es negativo ( 2.2.4a).
Me parece que en este caso lo más adecuado sería hacer una pausa con una llamada al sistema, así:
system("PAUSE");
previamente adosando la librería stdlib.h
Una cosa que no te expliqué es por qué diablos mi cambio de 1 a 1u arregló todo.
La razón es muy oscura.
Tiene que ver con la promoción automática de tipos de datos enteros en una operación aritmética.
Fijate que, aunque (1u << k) ahora es un unsigned int, gracias al sufijo u, resulta que n = -2 sigue siendo negativo.
Así que, ¿qué es lo que ocurre cuando hacemos (n & (algo-unsigned-int))?
Además, debemos recordar que estamos en la situación en que el "algo" tiene un bit izquierdo igual a 1.
Ahí hay que estudiar las complicadas reglas de promoción de tipos.
La verdad es que no me quedan muy claras estas reglas (están en la sección 7.4 del libro de King).
Pero es posible que ambos operandos hayan promocionado a unsigned int antes de llevar a cabo la operación &, y entonces el resultado se consideraría de tipo unsigned int.
En ese caso, el posterior corrimiento a la derecha con >> k, k = 31, provocaría que se agreguen 0's por la izquierda...
:banghead: :banghead: :banghead:
Otherwise, if the operand that has unsigned integer type has rank greater or equal to the rank of the type signed integer
converted
to unsigned
of the other operand, then the operand with signed integer type is converted to the type of the operand with
unsigned integer type.
Me parece que en este caso lo más adecuado sería hacer una pausa con una llamada al sistema, así:
system("PAUSE");
previamente adosando la librería stdlib.h
Muchas Gracias, Argentinator, eso es lo que buscaba, un comando tipo el stop() como el del Java u otros lenguajes así; sabía que tenía que tenerlo, porque el "C" es el padre de todos estos lenguajes.
Yo recuerdo cuando apareció el "C" en el mercado allá por los años ochentaitantos, leí un artículo en una de aquellas revistas (No sé si era Micromanía, Microhoby, o Microsoft, que también entonces tenía su revista para usuarios de Spectrum, Comodore y MSX). Se decía que incorporaba una serie de características revolucionarias respecto de los lenguajes más usados en aquella época, como Pascal, Cobol o Basic. Y una de esas cosas era que se compilaba más fácilmente y que corría como un lenguaje de bajo nivel. Por entonces existían compiladores para el Basic, y muchos "videojuegos" (llamémosles así aunque haya una gran diferencia con los de hoy) se escribían en ese lenguaje y después se compilaban (aunque había quien escribía juegos y programas pokeando binarios directamente en memoria, o sea, no ya en ensamblador, sino en el más puro código máquina; también leí un artículo, en una de esas revistas, sobre un estudiante de colegio que programó así un juego comercial para "Dinamic", una firma famosa de entonces de juegos para ordenador).
Y es que el Basic de la primera época tenían comando llamado Poket con el que se podía hacer eso, meter los bytes a mano directamente en una dirección de memoria de la pila de máquina; así, por ejemplo, podías cambiar de golpe el color de la pantalla, la dirección del cursor, las mayúsculas... o introducir una orden "stop" que bloqueaba el Basic y tenias que apagarlo.
Bueno, que me he enrollado :D voy a leer lo que habéis escrito.
Saludos.
Ahora, fijate lo que le contesté a PabloN: escribí un par de líneas que comparan -1 con 0, y en un caso me da que -1 es mayor y en otro que es menor. >:D
Meterse en los detalles técnicos de la definición del lenguaje C es costoso, porque no requiere programas complicados, sino mucho esfuerzo mental, jejeje.
Fijate que el programita que demuestra que el C anda para el diablo, tiene dos líneas:
#include <stdio.h>
int main(){
printf("(-1 + 0)/2 = %d\n\n", (-1 + 0) / 2);
printf("(-1 + 0u)/2 = %d\n\n", (-1 + 0u) / 2);
getchar();
}
En cuanto a explicar Java, no será parte de este curso... :'(
¿Cómo entiende "0u" la maquina, qué es para ella la u, un indicador de estado de algún bit de cierto byte relacionada con alguna dirección importante de memoria; una orden...? Quizá lo supe, pero si lo supe no me acuerdo; ¿ves?, es lo que me pasa.
cuántos bits, en decimal, tiene un byte
El problema está en que el operador de suma: +
hace una conversión de tipos de datos desastrosa,
al convertir el -1 a un entero sin signo, dejando la representación interna de bits a su suerte.
Veámos, voy a intentar interpretarlo a ver si estoy en lo cierto:
#include <stdio.h>
// Incluye una librería con una serie funciones prefijadas entre la las cuales, imagino, está definido el significado de “int”, “ unsigned”, etc.
int main()
// Supongo que quiere decir que en el área local, o zona de la memoria principal donde se guardan las rutinas del programa, todas las variables o constantes que se definan serán entendidas por la máquina como valores enteros.
{
unsigned int cero = 0;
// Esto no sé del todo cómo entenderlo, parece que define una constante llamada “cero” la cual es definida a su vez como entera, sin signo y de valor 0. Los entresijos del comando unsigned -en cuanto al funcionamiento de la máquina- se me escapa; yo sé que hasta el 127 decimal los entiende positivos , así, el -1 se expresa como 256-1, el -2 como 256-2... y cuando llega al 127 es positivo; esto depende en binario del séptimo bit, que pasa a valer 0 de 127 para abajo... Dado esto, no sé cómo la hace para considerar un número sin signo, pues el séptimo bit será cero ó 1; creo que nunca lo estudié o nunca leí sobre ello.
printf("(-1 + cero)/2 = %d\n\n", (-1 + cero) / 2 );
// Aquí se imprime un par de números separados por una coma. Creo, por lo que he ido viendo, que la instrucción %d llama a un tipo de variables o cosntantes (alfanuméricas, numéricas enteras, etc., según la letra que va detrás del %); en este caso parece que guarda el resultado de (-1 + cero)/2, pero no estoy seguro del todo de cómo funciona, es una instrucción muy nueva para mí que no recuerdo haber manejado mucho; leí que cuando es %c se refiere a variables tipo char o algo así pero poco más. El otro número detrás de la coma no va entre comillas, por tanto no es un valor “alfanumérico” (que digo yo en plan antiguo, no sé si se usa así todavía) con lo que la cuestión puede estar también relacionada con este tema del tipo de variables que resultan incompatibles según las instrucciones
Primero convierte ambos operandos al tipo "unsigned int".
No le importa qué le ocurre al -1 en esa conversión.
Luego los suma.
Te hago un comentario adicional.
En lenguajes como BASIC o Pascal, no está permitido intercambiar ciertos tipos de datos distintos.
Sobre este punto estoy teniendo el cuidado de diferenciar hasta dónde el estándar asegura tal o cual cosa, y a partir de dónde es que ya no asegura nada, y las decisiones las toma el compilador que nosotros usamos.
En tu frase:Citarse puede investigar sobre cómo representa C cada tipo de datos.
Lo correcto sería decir "se puede investigar sobre cómo representa el compilador GCC cada tipo de datos". ;) ;) ;)
En la universidad lo que enseñan es a razonar algoritmos, y el lenguaje es tema secundario, lo cual está bien, porque uno tiene que aprender a pensar los problemas informáticos en forma independiente al lenguaje que está usando.
Ahora estoy con los tipos de datos, sin analizar los operadores, que son muchos.
Pero me parece muy bien la sugerencia, seguramente le dedicaré sus buenos capítulos.
Creo que el problema podía estar en el tipo de datos que automáticamente se asigna a los números enteros.
Según las reglas de asignación de tipos, el 1 "intenta" ser un signed int, si es que cabe ahí.
Como cabe, lo pone de ese tipo.
Después, la operación (1 << k) conserva el tipo de datos, porque es sólo un corrimiento de bits.
El resultado será un entero positivo para k < 31 porque el bit de signo sigue siendo 0.
Mientras que para k = 31, el "1" ya ha llegado al bit de signo, el primero de todos: 1000000000...
En ese caso, como se trata de un signed int, el valor que toma es el de un número negativo, el más negativo de todos, digamos.
El código siguiente:
for(k=0; k<=31; k=k+1)
printf("k==%d: (1 << k) == %d\n ",k, (1 << k));
Genera esta salida:
k==0: (1 << k) == 1
k==1: (1 << k) == 2
k==2: (1 << k) == 4
k==3: (1 << k) == 8
k==4: (1 << k) == 16
k==5: (1 << k) == 32
k==6: (1 << k) == 64
k==7: (1 << k) == 128
k==8: (1 << k) == 256
k==9: (1 << k) == 512
k==10: (1 << k) == 1024
k==11: (1 << k) == 2048
k==12: (1 << k) == 4096
k==13: (1 << k) == 8192
k==14: (1 << k) == 16384
k==15: (1 << k) == 32768
k==16: (1 << k) == 65536
k==17: (1 << k) == 131072
k==18: (1 << k) == 262144
k==19: (1 << k) == 524288
k==20: (1 << k) == 1048576
k==21: (1 << k) == 2097152
k==22: (1 << k) == 4194304
k==23: (1 << k) == 8388608
k==24: (1 << k) == 16777216
k==25: (1 << k) == 33554432
k==26: (1 << k) == 67108864
k==27: (1 << k) == 134217728
k==28: (1 << k) == 268435456
k==29: (1 << k) == 536870912
k==30: (1 << k) == 1073741824
k==31: (1 << k) == -2147483648
Podría ser alguna cuestión de la función printf (pero no, porque printf imprime correctamente datos de tipo signed int), así que podemos verificar el signo. Basta depurar con algo como:
printf("%d\n", (1 << 31) < 0);
que dio salida "1" (verdadero).
Por otra parte, al hacer la máscara de bits con n = -2, que aparentemente, como vos decís, tiene representación complemento a dos,
el resultado de (n & (1 << 31)) tiene que dar esto: 1000000000000000.....
De nuevo, eso como signed int es el número -2147483648.
Cuando lo volvés a correr hacia la derecha con >> k, ¡va agregando 1's a la izquierda! :o
El resultado de (n & (1 << k)) >> k, con k = 31, es 1111111111111..... >:(
Pareciera que el corrimiento a derecha no funciona bien.
Al parecer esto no está bien definido en el estándar cuando se trata de números negativos.
Así que depende de la implementación.
Nuestro compilador lo que hace con el corrimiento a la derecha es conservar el bit de signo.
Si el número es positivo, hace lo que esperabas que hiciera, agrega 0's a la izquierda.
Pero si es negativo, agrega 1's por la izquierda, porque en cada corrimiento de los 31 que hace, va agregando un 1 por la izquierda...
Como 111111111111.... es la representación binaria de -1, eso explica el -1 al principio de la salida de tu programa.
Conclusión: El problema no es la representación binaria del -2, sino cómo se implementa en forma local (en el compilador) la operación de corrimiento a derecha.
Te hago un comentario adicional.
En lenguajes como BASIC o Pascal, no está permitido intercambiar ciertos tipos de datos distintos.
Sobretodo Pascal es muy restrictivo con ese tipo de cosas.
En Pascal no se puede sumar un "char" con un "integer", pero en C sí se puede.
El ejemplo de Pascal muestra más claro qué quiere decir tener tipos de datos distintos.
Son atributos de las variables, que no tienen nada que ver con el dato que guardan dentro de sí.
Las reglas de conversión de tipos de datos que sigue el C, no se fijan en ningún momento en el valor concreto que tienen las variables, sino sólo en cuál es el "tipo de datos" que tiene establecido.
A esa conversión de tipos de datos prevista en el lenguaje para que se realice de forma "automática" (es decir, sin ser explicitada por el programador) se le suele denominar casting implícito.
En una futura ocasión voy a explicar mejor cómo funciona el printf().
Pero en esencia, la opción %d dice que en ese lugar se va poner un número, que es el primer dato o expresión que aparece después de la coma.
Pero no sé qué trascendencia tiene que sea una "d", una "c", no sé si es verdaderamente importante, porque probé a cambiar la letra en algunos sitios y funcionaba lo mismo; es decir, no sé si en algunos casos poner una letra inadecuada, según el tipo de variable, puede dar lugar a un error que estropee el programa o se puede uno despreocupar de ello.
Me parece que en este caso lo más adecuado sería hacer una pausa con una llamada al sistema, así:
system("PAUSE");
previamente adosando la librería stdlib.h
______________
#include <stdlib.h>
#include <stdio.h>
void main(void)
{
int a;
printf("Escriba un numero: ");
scanf(" %d", &a);
if(a>0)
printf("Es positivo\n\n");
system("PAUSE");
}
La verdad no sé qué decirte, porque a mí me funciona sin problemas, ni avisos de ningún tipo.
No tendría por qué haber problemas.
¿Habrás tocado opciones de la configuración?
Yo no he tocado nada, salvo la opción que da al compilador "soporte para ANSI".
Pero igual esto no afecta en nada.
Si necesitás un int en vez de un void, usalo y listo.
Es más correcto y todo:
int main(void)
El lenguaje C no es lenguaje de máquina, y entonces la manera en que se representan internamente los datos depende de cada compilador.
No es algo que te puedas aprender, porque no está fijado por las reglas del lenguaje C.
Un programador en C no tiene por qué saber o supone cómo se representan los números (o cualquier dato) internamente.
Terminé por fin con todos los detalles técnicos de los tipos de datos enteros. :banghead: :banghead: :banghead:
¡Es terrible este tema!
He sufrido mucho escribiendo esos dos pots. :'( :'( :'( :'( :'(
El primero sólo lo retoqué en un par de párrafos, y el 2do terminé de editarlo.
Ahí van (no hagan caso del post que sigue después de un programa que lee archivos de texto, que está descolgado del tema).
Enteros en C (parte I) (http://rinconmatematico.com/foros/index.php?topic=64835.msg260467#msg260467)
Enteros en C (parte II) (http://rinconmatematico.com/foros/index.php?topic=64835.msg260468#msg260468)
Todo el manejo de los tipos de datos enteros es muy engorroso, complicado, lleno de excepciones, consideraciones, vueltas y contratuercas.
Me costó porque no quería dejar la tarea incompleta.
También les estoy dejando una muy buena bibliografía.
Yo confío en que no me estás mintiendo...
Nos queda pendiente analizar un detalle técnico importante:
¿Son iguales el número de bits de las versiones signed y unsigned de un tipo entero dado?
En general, se acostumbra ;) ;) que la versión signed de un tipo entero tenga la misma longitud que su compañera unsigned, y así la precisión será exactamente 1 menos que de la compañera unsigned.
Pero el estándar no obliga a esto, y puede ocurrir que los tipos signed podrían ser más pequeños.
Lo que el estándar sí obliga es que el rango de valores positivos y los bits que representan valores de la versión signed encajen a nivel de bits la versión unsigned, de manera que representen el mismo valor matemático.
Así, podría ocurrir que un signed int tenga 1 bit más que su compañero unsigned int, si ambos comparten los mismos valores positivos, ya que el signed int además debe contener el bit de signo.
(Incluso hay ejemplo de un sistema de la vida real que trabaja así).
Pero en todo otro caso, el número de bits de un signed será menor o igual :) que la de su compañero unsigned.
Inclusive podría ocurrir que la versión unsigned tenga varios bits más.
Precaución: A nivel de bits, se puede dar el caso que los bits de valor sean de cierta forma, pero que su representación como objeto en memoria sea algo diferente, por más que en ambos casos se hable de bits bien ordenaditos y todo.
Nosotros estamos suponiendo que ambas cosas son lo mismo, para no marearnos.
Pero en algún momento tendríamos que estudiar la diferencia entre estos dos aspectos.
También les estoy dejando una muy buena bibliografía.
La mayoría de los textos son gratuitos por internet:
Bibliografía para C (http://rinconmatematico.com/foros/index.php?topic=64835.msg260248#msg260248)
:-* :-*
Sí quedaba claro, básicamente, cómo se almacenaban los datos; en un byte había ocho celdillas y las combinaciones que se podían formar con éstas; si en una celdilla había con una carga eléctrica positiva, ese bit era un 1, si estaba descargada era un cero.
Feriva again: ¿Estás pudiendo leer con comodidad las notas? Mario una vez me advirtió de que el exceso de colores puede dificultad la lectura a determinados tipos de ojos . :-\
Se puede hacer un programita que saque todos los colores y deje el resto del texto intacto...
Queda pendiente para más adelante.
Buenas.
Otro cambio:
En el primer post, en donde se explica cómo instalar el IDE DevC++,
había una opción de configuración seleccionada.
La he quitado, y ahora dice que lo mejor es "no tocar las opciones de configuración".
En el próximo post se explicará cómo tocar opciones del Compilador, acorde a nuestras necesidades.
No hace falta reinstalar todo.
Ya voy a postear sobre el tema.
Por ejemplo en ésta tan sencilla, funciona pero me manda ese mensaje
#include <stdio.h>
int a,b;
main()
{
printf(" %d", 5+6);
getchar();
}
Hay que rellenar los "huecos".
O bien poner
void main(void)
o bien
int main(void)
Pero no sólo: main()
A ver si corrigiendo eso el programa ya te compila bien.
Hay que rellenar los "huecos".
O bien poner
void main(void)
o bien
int main(void)
Pero no sólo: main()
A ver si corrigiendo eso el programa ya te compila bien.
Hola, Argentinator. Con el int main(void) me sigue enviando el mensaje, con el void main(void) lo manda y no se abre. Pero no importa, el caso es que se abra y funcione, de momento lo que me interesa es ir viendo si soy capaz de escribir cosas que corran aunque sean muy elemntales.
He leído lo nuevo y lo he asimilado por encima, pero tengo que probar el programa que has puesto y mirar todo más despacio, que es mucho arroz para tan poco pollo (el pollo soy yo :) claro ).
Saludos y gracias.
Para darle un nombre [al programa], y de paso ya tenerlo guardado en el disco duro, vamos al menú Archivo, clic en Guardar Como....
Aparece un cuadro donde hemos de escribir un nombre para nuestro archivo.
También aparece debajo un desplegable con opciones para el Tipo de Archivo.
La opción por defecto para archivos nuevos es la C++ source files.
Entonces abrimos el desplegable y seleccionamos la opción C source files
Ahora en el Nombre de Archivo ponemos [por ejemplo] HolaMundo.c (en general Nombre-de-archivo.c).
Nos aseguramos de que va a guardar nuestro archivo en la carpeta "Mis_Proyectos_C". Si no aparece, la buscamos hasta encontrarlo.
Por fin, hacemos clic en Guardar.
He leído lo nuevo y lo he asimilado por encima, que es mucho arroz para tan poco pollo
Nuevo post: Testeando Tipos Enteros en C (http://rinconmatematico.com/foros/index.php?topic=64835.msg260792#msg260792)
Después de haber explicado temas intrincados, complejos, difíciles, con el mayor rigor posible,
he escrito un post totalmente casero, lleno de truquitos "para salir del paso".
Lo más grave es que ese nivel poco serio de programación se lo he mostrado al mundo entero, y como parte de un curso. >:D
De a poco iremos mejorando nuestras herramientas de programación, y nuestro estilo de programación.
(creo :-[ )
pero ya me fijé también en eso y aun así ocurre con el main() a palo seco;
Cuando uno no está seguro de si el compilador está trabajando limpiamente, quizás convenga "hacer una limpieza", del siguiente modo:
pero me pide el int para el main; se lo pongo y ya no se queja más.
Pero acá conviene tener en cuenta algunas cosas.
No deberías pensar en N como una "variable".
La N es sólo una "macro"...
Anuncio:
He puesto 3 posts más, relativos al testeo de los rangos de valores de los tipos enteros.
http://rinconmatematico.com/foros/index.php?topic=64835.msg260963#msg260963
http://rinconmatematico.com/foros/index.php?topic=64835.msg260972#msg260972
http://rinconmatematico.com/foros/index.php?topic=64835.msg260976#msg260976
Otra cosa que he visto, así por encima, es que una comparación falla en el rango de tipo char, hay un 255<=127
He tenido que descomentar esto, me fallaba directamente ::)
/* Nota: La macro PAUSA es sólo una solución casera. Puede fallar si antes se
han hecho operaciones de lectura de datos con scanf, por ejemplo.
Usar con precaución.
Si no funciona, descomentar el siguiente trozo de código:
*/
#include <stdlib.h>
#ifdef PAUSE
#undef PAUSE
#endif
#define PAUSE system("PAUSE")
Ya lo arreglé en el post, y también en el archivo adjunto.
Ahora tendría que funcionar bien, sin necesidad de descomentar nada.
Saludos
Ahí puse unos truquillos para ver más cómodamente la salida de información de la pantalla en un archivo Word por ejemplo.
Saludos
Agregué el Truco número 5, que genera y abre un archivo HTML en el navegador!!! :o
Altamente recomendado. ;D
Para enviar ejecutables por email hay que ponerlos dentro de un archivo comprimizo ZIP o RAR, ya sea usando WINZIP o WINRAR.
El GOTO de C es así:
Hay que definir una etiqueta:
label hola;
Luego poner la etiqueta en el punto donde queremos ir, en el salto del goto, seguida del signo "dos puntos":
hola:
Luego poner goto seguido de la etiqueta:
goto hola;
Disculpá, me confundí.
En C no hace falta declarar la etiqueta con label.
Ni siquiera reconoce la palabra label.
Funciona así no más.
Saludos
Sí he probado lo del HTML, y se ve bien, lo que ocurre es no es una pantalla "interactiva", si pones un scanf que te pide un dato, no puedes escribir, no es lo mismo que la pantalla negra.
Sí he probado lo del HTML, y se ve bien, lo que ocurre es no es una pantalla "interactiva", si pones un scanf que te pide un dato, no puedes escribir, no es lo mismo que la pantalla negra.
Ya sé...
Ya voy a pensar en algo.
¡Estos hombres de poca fe!
Por ahora no lo voy a hacer.
Además, ando con otras ideas en la cabeza.
Quiero hacer unas macros que sirvan, no sólo para obtener una salida para HTML, sino para cualquier otra cosa que a uno se le ocurra.
Por ejemplo, un post de acá del foro.
Otra cuestión: Estuve probando macros para distintas salidas, y una de ellas es un post para el foro.
Me dio esto:
Otra cuestión: Estuve probando macros para distintas salidas, y una de ellas es un post para el foro.
Me dio esto:
Y, una vez que se visualiza el programa en la pantalla, ¿se puede acceder al curso pinchando? Aquí ya se ve que sí, pero la cuestión es si se puede en el archivo que genera el programa a partir del ejecutable.
Si encontramos algo simple para manejar formularios en PHP, bienvenido.
Hasta ahora no he tenido suerte.
En el caso de la salida estándar por ventana de comandos... ahí no se puede acceder al enlace, claro está.
Si encontramos algo simple para manejar formularios en PHP, bienvenido.
Hasta ahora no he tenido suerte.
Ni yo tampoco, no encuentro nada de momento :-\
Si he visto cómo se puede abrir una página web desde la consola que ejecuta el C++ (la negra que tanto te gusta :D ) con esto
system("Explorer \"http://rinconmatematico.com/foros/index.php?topic=64835.msg260248#msg260248\"");
Donde pone Explorer se pone el navegador que sea (en linux se puede poner otro navegador según he leído, pero en Windows a mí sólo me deja con Explorer).
Lo puedes poner detrás de la Url en el último programa que has hecho, al final del todo y antes de un getchar() con un letrero que diga "Pulse Enter para ir al curso... etc".
Saludos.
Lo importante es ver cómo se logra eso con las macros.
Además, la idea va por otro lado, no tanto lo visual:
Lo importante es ver cómo se logra eso con las macros.
Además, la idea va por otro lado, no tanto lo visual:
Ya entiendo lo que dices, que tiene interés como ejercicio.
Me ha pasado una cosa rara con el MSdos, al ejecutar OUTPU.TXT o OUTPUT punto lo que sea, ahora se me abre siempre la ID con el código fuente del programa que quiero abrir, no sé que habré hecho, porque no tiene lógica ninguna... :o
La verdad no sé.
La verdad no sé.
Creo que era porque tenía la IDE y la carpeta juntas en el Escritorio.
No, ya está, era que en vez de poner HTMLHolaMundo.exe, ponía punto c, y claro, por eso abría la IDE.
Mira que no haberte dado cuenta :D :D
Mira, éste es el código fuente del archivo OUTPUT.HTML tal y como queda, lo he copiado:
<pre><font face="Arial"><font color="blue"><b>¡Hola Mundo HTML desde C!
</b></font>* <u>Ejemplo de efecto:</u> <font color="blue">¡Hola mundo!
</font><font color="blue"><u><b>* Ejemplo de negrita, subrayado, en color rojo.
</b></u></font><a href="http://rinconmatematico.com/foros/index.php?topic=64835.msg260248#msg260248">Programación en C: curso online</a></font>
En las últimas versiones de "todo este asunto" (por llamarlo de alguna manera),
el archivito BAT funciona de otra manera.
Ese proceso por lotes EYV.BAT ahora "no le gusta" que escribas directamente la extensión .EXE.
La pone él solo, por otras razones.
Te aviso por las dudas llegás a usar algo de eso.
Saludos
Código: [Seleccionar]Mira, éste es el código fuente del archivo OUTPUT.HTML tal y como queda, lo he copiado:
<pre><font face="Arial"><font color="blue"><b>¡Hola Mundo HTML desde C!
</b></font>* <u>Ejemplo de efecto:</u> <font color="blue">¡Hola mundo!
</font><font color="blue"><u><b>* Ejemplo de negrita, subrayado, en color rojo.
</b></u></font><a href="http://rinconmatematico.com/foros/index.php?topic=64835.msg260248#msg260248">Programación en C: curso online</a></font>
O sea, lo que hace el documento es recibir el texto como fuente, evidentemente, no como texto visible de HTML en ningún caso.
Si haces un sólo macro que llame a una hoja de estilos (una que esté ya hecha, que se puede pillar de cualquier página, para no tener que aprender nada, sólo para probar) y la metes en la carpeta de los archivos, guardada con extensión punto css, cualquier documento exe que lleve ese macro y el printf de ese macro, tendrá el tamaño, color de letra, etc., que aparece en la hoja de estilos. Claro que no se puede personalizar cambiando el valor de "x" como en tu programa, pero es otro tipo de experimento también interesante. Mañana intento hacer un programa análogo al tuyo, más sencillo, pero con hoja de estilos, a ver si me sale.
El macro tiene sólo que definir esta llamada
<LINK href="Argentinator-style.css" rel="stylesheet" type="text/css">
Para probar, basta con esta hoja de estilos elemental que he tomado de una página en la que viene como ejemplo:
P.especial {
color : green;
border: solid red;
}
Eso se guarda con el bloc de notas y con extensión "nombre.css" y ya está, se hace el macro del link y a correr :) tiene que salir.
Lo he sacado de aquí: http://html.conclase.net/w3c/html401-es/present/styles.html.
Saludos y buenas noches.
O sea, lo que hace el documento es recibir el texto como fuente, evidentemente, no como texto visible de HTML en ningún caso.
<LINK href="Argentinator-style.css" rel="stylesheet" type="text/css">
Citar<LINK href="Argentinator-style.css" rel="stylesheet" type="text/css">
No le pongas "Argentinator", que la gente va a creer que me salió a mí.
A menos que estés sugiriendo que elija mi propio estilo.
Pero en eso no soy muy exigente. Mi estilo es: "cualquier cosa que no sea la ventana de comandos de MS-DOS".
En las últimas versiones de "todo este asunto" (por llamarlo de alguna manera),
el archivito BAT funciona de otra manera.
Ese proceso por lotes EYV.BAT ahora "no le gusta" que escribas directamente la extensión .EXE.
La pone él solo, por otras razones.
Te aviso por las dudas llegás a usar algo de eso.
Saludos
Pero si no le pongo la extensión .exe me crea el archivo pero no me abre la ventana del navegador automáticamente, tengo que ir a la carpeta que se ha creado y pinchar.
Sí funciona lo del CSS, y cualquier cosa siempre que se tenga cuidado con los símbolos especiales de HTML que se puedan confundir con los que utiliza el C, pero los macros no tienen nada especial en este caso que no tengan en otro, guardan cadenas, parámetros o cosas que también puedes poner directamente en un printf.
Mira, ejecuta esto:
#include <stdio.h>
int main(void){
printf("<img src=\"http://informaticaloren.files.wordpress.com/2012/07/analista-informaticaloren3.jpg\">");
}
De acuerdo, le ponía la extensión por si acaso.
Gracias.
Citar<LINK href="Argentinator-style.css" rel="stylesheet" type="text/css">
No le pongas "Argentinator", que la gente va a creer que me salió a mí.
A menos que estés sugiriendo que elija mi propio estilo.
Pero en eso no soy muy exigente. Mi estilo es: "cualquier cosa que no sea la ventana de comandos de MS-DOS".
Pobre ventana, con lo mona que es y lo bien que veo ya las letras blancas sobre fondo negro, que no me da reflejo.
Bueno, lo de Argentinator era un homenaje.
¿Viste esto que añadí en azul en el otro comentario?
#include <stdio.h>
int main(void){
printf("<img src=\"http://informaticaloren.files.wordpress.com/2012/07/analista-informaticaloren3.jpg\">");
}
Funciona, y con un vídeo también; lo estilos CSS por supuesto que funcionarán, no puede ser de otra manera, pero ya no trae más cuenta hacerlo, ya he entendido como va. Es que al principio me despistaba, no sabía qué era lo que se cargaba en el archivo de salida, por un momento había pensado que era una mezcla de fuente y texto plano, pero no podía ser, claro :P
Ah, he probado una operación matemática sencilla definida mediante un macro y añadida a la foto del chiste; para ver si la evaluaba; y sí, la evalúa y el resultado aparece en el HTML junto a lo demás
Gracias, hasta mañana.
no sabía qué era lo que se cargaba en el archivo de salida, por un momento había pensado que era una mezcla de fuente
La verdad es que no logro ver nada.
Me da error 404.
Logré ver sola la imagen del chiste. Pero no veo nada más.
Bueno, lo del iframe funciona.
Sin embargo no hay manera de solucionar lo del scanf usando sólo HTML,
porque no hay etiquetas HTML para interactuar con el usuario.
No importa, hay otras cosas que hacer antes de llegar al bendito scanf.
Bueno, lo del iframe funciona.
Sin embargo no hay manera de solucionar lo del scanf usando sólo HTML,
porque no hay etiquetas HTML para interactuar con el usuario.
No importa, hay otras cosas que hacer antes de llegar al bendito scanf.
No, no se puede porque parece ser que el archivo HTML que genera es simplemente eso, no guarda el exe dentro; basta tan solo con mirar el peso del archivo generado, es un simple HTML. Porque podríamos hacer que los parámetros de las macros fueran a la vez variables de HTML dinámico y cambiarlas a través de un formulario para que, por ejemplo, al recibir los nuevos datos se haga una operación nueva; pero no me he molestado en intentarlo, no va a funcionar por eso, porque el exe ya no está ahí dentro, se ha ido al cielo o al limbo de los archivos, que también se van al cielo todos los archivos buenos, parodiando a Machín y su canción angelitos negros :laugh:
Saludos.
En la pantalla negra, al pinchar en la esquina, además de "propiedades" tiene otra opción que es "predeterminadas", y ahí ya si guarda las modificaciones en cuanto a tamaños y colores, el problema siguen siendo los acentos, la "ñ" y tal, que sería cuestión de agregar a la configuración del CMD la codificación necesaria
Tengo una duda sobre qué tema seguir desarrollando en la teoría.
Pensaba seguir con los tipos de datos numéricos de coma flotante,
pero me parece que para expicar apropiadamente los detalles de ese tipo de datos hay que haber dicho algo sobre los operadores aritméticos, de los cuales no he dicho nada, y los pesaba postergar para después que hubiésemos terminado de explicar los tipos mismos.
En cuanto a la configuración de la ventana de comandos, he agregado un post a la teoría:
Trabajando en la ventana de comandos. (http://rinconmatematico.com/foros/index.php?topic=64835.msg260503#msg260503)
Quiero agradecer a Feriva su colaboración en este tópico, que a mí me produce tantas lágrimas.
Al final me decidí por el tema de los números de punto flotante (o coma flotante).
Es un tema complicado, y entonces habrá varios posts meramente teóricos, sin programación.
Después recién podremos hacer algunos experimentos de programación y ver qué sale.
Bueno, en realidad hay que dejar claro que se trata de base 10,
Cuando uno escribe una constante hexadecimal:
1.3p-20
ese "20" está en base 10.
Además, la base elevada a 10 tampoco es 16, sino 2.
A ver si con un ejemplo se ve mejor:
15.0p+10
es el número (15) en base 16 (o sea 21 en base 10) multiplicado por 2 elevado a +10.
El resultado es \( 21\cdot 2^{10} = 21 \cdot 1024 \).
Acá lo importante es entender qué significa esa notación, o sea, qué entiende el compilador.
_______________
En cuanto a entender el compilador... es algo que ocurre con la práctica.
Yo tengo que dejar los detalles asentados en la parte teórica.
Pero es la práctica lo que nos mostrará el por qué de las normas y sus detalles quisquillositos.
Saludos
Si no, no tiene por qué ocurrir (fijate si no en la sucesión \( (-10)^k \)).
Para jugar con conversiones de binario a decimal, incluyendo partes fraccionarias y todo,
podés ir a esta página:
http://www.mathsisfun.com/flash.php?path=/numbers/images/binary-dec-hex.swf&w=798&h=198&col=%23FFFFFF&title=Binary%2FDecimal%2FHexadecimal+Converter (http://www.mathsisfun.com/flash.php?path=/numbers/images/binary-dec-hex.swf&w=798&h=198&col=%23FFFFFF&title=Binary%2FDecimal%2FHexadecimal+Converter)
Una errata: En la teoría hice los ejemplos con \( 1+2^{-24} \), pero tengo que cambiarlos a \( 1+2^{-23} \), porque sólo se admiten 24 dígitos binarios significativos en Single Precision, y el número \( 1+2^{-24} \) tiene 25 dígitos significativos.
No creo que esto me cambie mucho la exposición o el sentido de los ejemplos,
pero tendré que hacer los cambios, por las dudas, y revisar todos los números.
Un saludo
Si no, no tiene por qué ocurrir (fijate si no en la sucesión \( (-10)^k \)).
Ya, pero eso no converge a un límite, y además lo que va cambiando es el signo de la cifra, no me refería a eso.
no creo que nadie se equivoque y, si se equivoca, se lo canta el ordenador dándole un resultado erróneo; es lo que tiene la programación, que o se hace bien o no anda.
Perdón, quise decir \( (-10)^{-k} \).
Ya arreglé los numeritos que estaban mal.
Había otra errata.
Creí por un momento que, al pasar de base 16 a base 2, era fácil identificar la paridad del último bit en base 2...
Pero eso no es tan así, y entonces quité ese párrafo. Sólo puse un ejemplo, y una pregunta para el lector de por qué es más o menos fácil detectar la paridad estando en base 16... ???
Así que, primero, me toca disculparme por este error,
y además ya he corregido los ejemplos en los que había void main(void) para poner int main(void).
Igual, creo que no es obligatorio poner una cláusula return, aún cuando el tipo de salida de main no sea void.
El post con los cambios sería éste:
http://rinconmatematico.com/foros/index.php?topic=64835.msg260748#msg260748 (http://rinconmatematico.com/foros/index.php?topic=64835.msg260748#msg260748)
Con esto, dejará de funcionar el programita HolaMundo2bisbis.c (que entonces quizá lo termine quitando de la teoría), y el menos importante ExperimentoBasura.c.
Esos programas están en las secciones: "De la eficacia a la elegancia - Macros del Preprocesador (parte I)" y "(parte II)".
Saludos
Otros tipos de punto flotante declarados en C,
En la librería math.h del estándar C están especificados, acorde a lo requerido por C99, los siguientes tipos de punto flotante:
float_t
double_t
Estos tipos de datos están pensados de la siguiente manera:
Supongamos que en nuestro sistema es posible acceder a tipos de punto flotante que tienen al menos la misma exactitud que float y/o double, pero que además permiten realizar cálculos más eficientes.
En ese caso, el programador puede elegir tomar ventaja de esa eficiencia, y para ello no tendría que hacer muchos cambios en su programa fuente en C, sino hacer algo tan simple como escribir float_t en vez de float y/o double_t en vez de double.
Qué es lo que representan exactamente estos tipos depende del hardware y/o de la implementación local del compilador, etc.
Sin embargo, el estándar C99 establece una pautas mínimas que han de cumplir,
y que dependen del valor asignado a la macro FLT_EVAL_METHOD, que está definida en la librería float.h:
Si el valor de FLT_EVAL_METHOD es 0,
entonces float_t coincide con float, y double_t coincide con double.
Si el valor de FLT_EVAL_METHOD es 1,
entonces float_t y double_t coinciden ambos con double.
Si el valor de FLT_EVAL_METHOD es 2,
entonces float_t y double_t coinciden ambos con long double.
Para otros valores de FLT_EVAL_METHOD, es la implementación local la que debe especificar qué tipos son float_t y double_t.
Bueno.
El programa anterior lo quité, y puse otro parecido, pero que no tiene la última parte.
Como sea, hay 3 posts de testeo de tipos de punto flotante, con 3 programas de testeo.
Por último, escribí un par de posts totalmente descontextualizados, en que no vemos nada del lenguaje C, sino sólo anécdotas de la vida, y consejos espirituales para programadores del siglo 21.
No sirve de nada que copie un programa de ese video de Youtube, porque el programa que tiene errores es el tuyo.
Por eso tengo que ver tu programa.
Además, aunque el programa del video es corto, no lo pienso copiar a mano, porque encima lo va cambiando durante todo el video, y tengo que comerme toda la explicación hasta ver qué diablos es lo que hace.
No voy a mirar videos...
Bueno, hombre, no te pongas así :laugh: :laugh: Decía sólo la primera parte hasta que ejecuta; lo he mirado y remirado, repasado puntos y comas, etc., pero introduzco el número y ahí se queda, el condicional que le sigue no corre. Pero da igual, ya lo repaso más veces, a ver...
Me puse celoso, me andás engañando con el tipo ese de youtube. :'(
HolaNo sirve de nada que copie un programa de ese video de Youtube, porque el programa que tiene errores es el tuyo.
Por eso tengo que ver tu programa.
Además, aunque el programa del video es corto, no lo pienso copiar a mano, porque encima lo va cambiando durante todo el video, y tengo que comerme toda la explicación hasta ver qué diablos es lo que hace.
No voy a mirar videos...
Bueno, hombre, no te pongas así :laugh: :laugh: Decía sólo la primera parte hasta que ejecuta; lo he mirado y remirado, repasado puntos y comas, etc., pero introduzco el número y ahí se queda, el condicional que le sigue no corre. Pero da igual, ya lo repaso más veces, a ver...
Me puse celoso, me andás engañando con el tipo ese de youtube. :'(
¡Oh no! Ya somos dos :-\ :-\.
Saludos :laugh:
Pero esto fue hace mucho :D Ya no me acuerdo del C desde que me hice pythonero.
Apuesto a que por lo menos sabés a día de hoy hacer un "Hola Mundo" en C :laugh:. ¡¡Sin leer y sin soplar de ningún mensaje anterior quiero ver un "Hola Mundo" hecho por feriva en 2019!! Luego lo podemos comprobar con todo lo anterior a ver si lo hiciste bien, si te parece.
Saludos
_Static_assert(0,"Hola mundo");
_Static_assert(0,"Hola mundo");
Y ¿eso se puede poner tal cual, sin librería y sin el main, o sigue haciendo falta?
Saludos.