Variables - Historial de revisiones

Erikcrane: /* Static Local */

2013-03-20T15:34:49Z

Static Local

← Revisión anterior		Revisión del 15:34 20 mar 2013
Línea 72:		Línea 72:
	= Static =		= Static =
	== Static Local ==		== Static Local ==
	Son variables que cuando acaba la función no se destruyen y matienen el valor cuando se vuelve a crear la función.		*Son variables que cuando acaba la función no se destruyen y matienen el valor cuando se vuelve a crear la función.
			*El espacio asignado en la memoria no cambia durante la ejecución del programa.

	== Static Global ==		== Static Global ==

Erikcrane: /* uintN_t/intN_t */

2013-03-20T15:05:00Z

uintN_t/intN_t

← Revisión anterior		Revisión del 15:05 20 mar 2013
Línea 68:		Línea 68:
	*uint8_t significa unsigned int de 8 bits. Las variables char también son de 8 bits y se podrian utilizar indistintamente, pero no es recomendable porque el código tiene más probabilidad de ser portable si se utilitza uint8_t para designar una variable de 8 bits debido a que no en todos los procesadores el char es de 8 bits. Con los int pasa lo mismo, en la tabla pone que son de 16 bits, pero puedes encontrar plataformas donde sean de 32 bits (creo que en los procesadores de 64 bits). En resumen, si se quiere estar seguro que el código va a ser compatible y las variables ocuparan solo lo que nosotros queremos que ocupen, es mejor utilizar las versiones uintN_t o intN_t.''[http://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char Extraído de Stack Overflow]''		*uint8_t significa unsigned int de 8 bits. Las variables char también son de 8 bits y se podrian utilizar indistintamente, pero no es recomendable porque el código tiene más probabilidad de ser portable si se utilitza uint8_t para designar una variable de 8 bits debido a que no en todos los procesadores el char es de 8 bits. Con los int pasa lo mismo, en la tabla pone que son de 16 bits, pero puedes encontrar plataformas donde sean de 32 bits (creo que en los procesadores de 64 bits). En resumen, si se quiere estar seguro que el código va a ser compatible y las variables ocuparan solo lo que nosotros queremos que ocupen, es mejor utilizar las versiones uintN_t o intN_t.''[http://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char Extraído de Stack Overflow]''

	*En la tabla de arriba vemos un extracto del archivo stdint.h. Vemos que uintN_t son typedef de tipos de variables. ~~Yo no se si es así solo~~ en los ~~compiladores de microcontroladores porque en todos ellos los tipos de variables ocupan el mismo espacio y en Ansi C el~~ uintN_t son tipos de variables ~~diferentes y por~~ lo ~~tanto lo expuesto en el punto anteior aún tendria validez~~, o ~~realmente los uintN_t~~ son ~~simples typedef~~. ~~Cuando tenga~~ más ~~tiempo puede~~ que ~~lo investigue para aclararlo, de momento me quedo con~~ que ~~los uintN_t los usaré para~~ asegurarme de que ~~las variables ocupan~~ lo que ~~quiero que ocupen.~~		*En la tabla de arriba vemos un extracto del archivo stdint.h. Vemos que uintN_t son typedef de tipos de variables. Según entiendo en el punto anterior los uintN_t/intN_t son tipos de variables (como lo es int, o char), pero viendo el archivo stdint.h son solo typedefs. Esto ya me lo miraré más a fondo. De momento lo que se es que si quiero asegurarme de que una variable me ocupe un tamaño concreto lo tengo que hacer con uintN_t/intN_t

	= Static =		= Static =

Erikcrane: /* Const */

2013-03-19T10:03:28Z

Const

← Revisión anterior		Revisión del 10:03 19 mar 2013
Línea 77:		Línea 77:
	= Volatile =		= Volatile =
	= Const =		= Const =
	~~Una variable~~ const ~~debe ser inicializada en su declaración~~. ~~Después~~ de ~~eso el compilador solo permitirá su lectura mas~~ no ~~su escritura~~		*Las variables const son constantes. Se definen al declararlas y luego no se pueden modificar, solo leer.
			*Siguen ocupando RAM.
			*Una forma de declarar constantes y que no ocupen RAM es con #define, pero no se si es una buena práctica

	= Boolean =		= Boolean =

Erikcrane: /* Static */

2013-03-19T10:01:22Z

Static

← Revisión anterior		Revisión del 10:01 19 mar 2013
Línea 71:		Línea 71:

	= Static =		= Static =
			== Static Local ==
			Son variables que cuando acaba la función no se destruyen y matienen el valor cuando se vuelve a crear la función.
			== Static Global ==

	= Volatile =		= Volatile =
	= Const =		= Const =

Erikcrane: /* Const */

2013-03-19T09:46:32Z

Const

← Revisión anterior		Revisión del 09:46 19 mar 2013
Línea 73:		Línea 73:
	= Volatile =		= Volatile =
	= Const =		= Const =
			Una variable const debe ser inicializada en su declaración. Después de eso el compilador solo permitirá su lectura mas no su escritura

	= Boolean =		= Boolean =

Erikcrane en 09:45 19 mar 2013

2013-03-19T09:45:28Z

← Revisión anterior		Revisión del 09:45 19 mar 2013
Línea 69:		Línea 69:

	*En la tabla de arriba vemos un extracto del archivo stdint.h. Vemos que uintN_t son typedef de tipos de variables. Yo no se si es así solo en los compiladores de microcontroladores porque en todos ellos los tipos de variables ocupan el mismo espacio y en Ansi C el uintN_t son tipos de variables diferentes y por lo tanto lo expuesto en el punto anteior aún tendria validez, o realmente los uintN_t son simples typedef. Cuando tenga más tiempo puede que lo investigue para aclararlo, de momento me quedo con que los uintN_t los usaré para asegurarme de que las variables ocupan lo que quiero que ocupen.		*En la tabla de arriba vemos un extracto del archivo stdint.h. Vemos que uintN_t son typedef de tipos de variables. Yo no se si es así solo en los compiladores de microcontroladores porque en todos ellos los tipos de variables ocupan el mismo espacio y en Ansi C el uintN_t son tipos de variables diferentes y por lo tanto lo expuesto en el punto anteior aún tendria validez, o realmente los uintN_t son simples typedef. Cuando tenga más tiempo puede que lo investigue para aclararlo, de momento me quedo con que los uintN_t los usaré para asegurarme de que las variables ocupan lo que quiero que ocupen.

			= Static =
			= Volatile =
			= Const =
			= Boolean =

Erikcrane en 09:39 19 mar 2013

2013-03-19T09:39:55Z

← Revisión anterior		Revisión del 09:39 19 mar 2013
Línea 1:		Línea 1:
			= Tipos de variables =
	{\| class="wikitable"		{\| class="wikitable"
	!Tipo de dato		!Tipo de dato
Línea 29:		Línea 30:
	Extraido de [http://www.cursomicros.com/avr/lenguaje-c/variables-y-tipos-de-datos.html cursomicros.com]		Extraido de [http://www.cursomicros.com/avr/lenguaje-c/variables-y-tipos-de-datos.html cursomicros.com]



			*Las caracteristicas signed o unsigned sirven para decir si el número podrá ser negativo. Si no se puede poner en negativo tendremos capacidad para más números

			*Las variables son espacios de memoria donde se guardan los datos necesarios par ala ejecución del programa. Estos datos pueden ser numeros enteros, numeros de coma flotante, ... Una cosa a tener en cuenta es que los caracteres son numeros que mediante la tabla ASCII se convierten en letras, pero lo que se guarda en memoria son números, no letras.

			= uintN_t/intN_t =
	{\|class="wikitable"		{\|class="wikitable"
	\|+stdint.h de AVR-GCC		\|+stdint.h de AVR-GCC
Línea 58:		Línea 66:
	Extraido de [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdint.html AVR Libc Home Page]		Extraido de [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdint.html AVR Libc Home Page]

	*Las ~~caracteristicas signed o unsigned sirven~~ para ~~decir~~ si el ~~número podrá~~ ser ~~negativo~~. ~~Si no se puede poner en negativo tendremos capacidad para más números~~		*uint8_t significa unsigned int de 8 bits. Las variables char también son de 8 bits y se podrian utilizar indistintamente, pero no es recomendable porque el código tiene más probabilidad de ser portable si se utilitza uint8_t para designar una variable de 8 bits debido a que no en todos los procesadores el char es de 8 bits. Con los int pasa lo mismo, en la tabla pone que son de 16 bits, pero puedes encontrar plataformas donde sean de 32 bits (creo que en los procesadores de 64 bits). En resumen, si se quiere estar seguro que el código va a ser compatible y las variables ocuparan solo lo que nosotros queremos que ocupen, es mejor utilizar las versiones uintN_t o intN_t.''[http://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char Extraído de Stack Overflow]''
	*uintN_t

	~~Las variables son espacios~~ de ~~memoria donde se guardan los datos necesarios par ala ejecución~~ del ~~programa. Estos datos pueden ser numeros enteros, numeros de coma flotante,~~ ..~~. Una cosa a tener en cuenta es~~ que ~~los caracteres~~ son ~~numeros que mediante la tabla ASCII se convierten en letras, pero lo que se guarda en memoria son números, no letras.<br/>~~		*En la tabla de arriba vemos un extracto del archivo stdint.h. Vemos que uintN_t son typedef de tipos de variables. Yo no se si es así solo en los compiladores de microcontroladores porque en todos ellos los tipos de variables ocupan el mismo espacio y en Ansi C el uintN_t son tipos de variables diferentes y por lo tanto lo expuesto en el punto anteior aún tendria validez, o realmente los uintN_t son simples typedef. Cuando tenga más tiempo puede que lo investigue para aclararlo, de momento me quedo con que los uintN_t los usaré para asegurarme de que las variables ocupan lo que quiero que ocupen.
	~~<br/>~~
	~~uint8_t significa unsigned int~~ de ~~8 bits~~. ~~Las variables char también son de 8 bits y~~ se ~~podrian utilizar indistintamente, pero no~~ es ~~recomendable~~ porque ~~el código tiene más probabilidad de ser portable si se utilitza uint8_t para designar una variable de 8 bits debido a que no~~ en todos los ~~procesadores~~ el ~~char es~~ de ~~8 bits.<br/>~~
	~~Con los int pasa~~ lo ~~mismo~~, ~~en la table pone~~ que ~~son de 16 bits~~, ~~pero puedes encontrar plataformas donde sean~~ de ~~32 bits (creo~~ que en los ~~procesadores~~ de ~~64 bits)<br/>~~
	~~<br/>~~
	~~En resumen, si se quiere estar seguro~~ que ~~el código va a ser compatible y~~ las variables ~~ocuparan solo~~ lo que ~~nosotros queremos~~ que ocupen~~, es mejor utilizar las versiones uintN_t o intN_t~~
	~~[http://stackoverflow~~.~~com/questions/1725855/uint8-t-vs-unsigned-char Discución en Stack Overflow]~~

Erikcrane en 09:24 19 mar 2013

2013-03-19T09:24:44Z

← Revisión anterior		Revisión del 09:24 19 mar 2013
Línea 59:		Línea 59:

	*Las caracteristicas signed o unsigned sirven para decir si el número podrá ser negativo. Si no se puede poner en negativo tendremos capacidad para más números		*Las caracteristicas signed o unsigned sirven para decir si el número podrá ser negativo. Si no se puede poner en negativo tendremos capacidad para más números
			*uintN_t

	Las variables son espacios de memoria donde se guardan los datos necesarios par ala ejecución del programa. Estos datos pueden ser numeros enteros, numeros de coma flotante, ... Una cosa a tener en cuenta es que los caracteres son numeros que mediante la tabla ASCII se convierten en letras, pero lo que se guarda en memoria son números, no letras.<br/>		Las variables son espacios de memoria donde se guardan los datos necesarios par ala ejecución del programa. Estos datos pueden ser numeros enteros, numeros de coma flotante, ... Una cosa a tener en cuenta es que los caracteres son numeros que mediante la tabla ASCII se convierten en letras, pero lo que se guarda en memoria son números, no letras.<br/>
Línea 66:		Línea 67:
	<br/>		<br/>
	En resumen, si se quiere estar seguro que el código va a ser compatible y las variables ocuparan solo lo que nosotros queremos que ocupen, es mejor utilizar las versiones uintN_t o intN_t		En resumen, si se quiere estar seguro que el código va a ser compatible y las variables ocuparan solo lo que nosotros queremos que ocupen, es mejor utilizar las versiones uintN_t o intN_t
			[http://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char Discución en Stack Overflow]

Erikcrane en 08:46 19 mar 2013

2013-03-19T08:46:47Z

← Revisión anterior		Revisión del 08:46 19 mar 2013
Línea 27:		Línea 27:
	\|64 bits		\|64 bits
	\|}		\|}
			Extraido de [http://www.cursomicros.com/avr/lenguaje-c/variables-y-tipos-de-datos.html cursomicros.com]

	{\|		{\|class="wikitable"
			\|+stdint.h de AVR-GCC
	\|-		\|-
	\|typedef signed char		\|typedef signed char
Línea 54:		Línea 56:
	\|uint64_t		\|uint64_t
	\|}		\|}
			Extraido de [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdint.html AVR Libc Home Page]

	*Las caracteristicas signed o unsigned sirven para decir si el número podrá ser negativo. Si no se puede poner en negativo tendremos capacidad para más números		*Las caracteristicas signed o unsigned sirven para decir si el número podrá ser negativo. Si no se puede poner en negativo tendremos capacidad para más números

Erikcrane en 08:42 19 mar 2013

2013-03-19T08:42:45Z

← Revisión anterior		Revisión del 08:42 19 mar 2013
Línea 6:		Línea 6:
	\|8 bits		\|8 bits
	\|-		\|-
	\|int (signed y unsigned)*		\|int (signed y unsigned)
	\|16 bits		\|16 bits
	\|-		\|-
Línea 28:		Línea 28:
	\|}		\|}

	*Unsigned		{\|
	*Signed		\|-
	*uint8_t		\|typedef signed char
	*Byte		\|int8_t
	*Int		\|-
	*Long		\|typedef unsigned char
	*Char		\|uint8_t
			\|-
			\|typedef signed int
			\|int16_t
			\|-
			\|typedef unsigned int
			\|uint16_t
			\|-
			\|typedef signed long int
			\|int32_t
			\|-
			\|typedef unsigned long int
			\|uint32_t
			\|-
			\|typedef signed long long int
			\|int64_t
			\|-
			\|typedef unsigned long long int
			\|uint64_t
			\|}

	*Las caracteristicas signed o unsigned sirven para decir si el número podrá ser negativo. Si no se puede poner en negativo tendremos capacidad para más números		*Las caracteristicas signed o unsigned sirven para decir si el número podrá ser negativo. Si no se puede poner en negativo tendremos capacidad para más números
	*En Arduino se puede poner la variable byte. Pero es un typedef de un char

	Las variables son espacios de memoria donde se guardan los datos necesarios par ala ejecución del programa. Estos datos pueden ser numeros enteros, numeros de coma flotante, ... Una cosa a tener en cuenta es que los caracteres son numeros que mediante la tabla ASCII se convierten en letras, pero lo que se guarda en memoria son números, no letras.<br/>		Las variables son espacios de memoria donde se guardan los datos necesarios par ala ejecución del programa. Estos datos pueden ser numeros enteros, numeros de coma flotante, ... Una cosa a tener en cuenta es que los caracteres son numeros que mediante la tabla ASCII se convierten en letras, pero lo que se guarda en memoria son números, no letras.<br/>
	<br/>		<br/>
	~~Según se ve en la tabla las~~ variables de ~~tipo char ocupan~~ 8 bits y se ~~suelen usar~~ para ~~los programas de los microcontroladores cuando necesitas de~~ una variable ~~que sabes~~ que no ~~será más grande~~ de 8 bits. ~~Cuando se usa no se utiliza~~ la ~~notación char a=1; sinó uint8_t (unsigned int 8~~ bits~~) o sint8_t~~ (~~signed int 8~~ bits), ~~pero esto~~ solo es ~~un typedef de unsigned char~~ o ~~signed char.~~		uint8_t significa unsigned int de 8 bits. Las variables char también son de 8 bits y se podrian utilizar indistintamente, pero no es recomendable porque el código tiene más probabilidad de ser portable si se utilitza uint8_t para designar una variable de 8 bits debido a que no en todos los procesadores el char es de 8 bits.<br/>
			Con los int pasa lo mismo, en la table pone que son de 16 bits, pero puedes encontrar plataformas donde sean de 32 bits (creo que en los procesadores de 64 bits)<br/>
			<br/>
			En resumen, si se quiere estar seguro que el código va a ser compatible y las variables ocuparan solo lo que nosotros queremos que ocupen, es mejor utilizar las versiones uintN_t o intN_t