Bits:
Colocando un bit:
Usamos el operador bit a bit OR ( | ) para colocar un bit.
numero |= (1<<x);
Colocamos un bit en x.
Limpiando un bit:
Usamos el operador bit a bit AND (&) para limpiar un bit.
numero &= ~(1<<x);
Limpiamos el bit x.
Cambiando un bit:
Usamos el operador bit a bit XOR (^) para cambiar un bit.
numero ^= (1<<x);
Cambiamos el bit x.
Leyendo un bit:
bit = numero & (1<<x);
Leemos el bit x de número y lo colocamos en la variable bit.
Estructuras:
Una estructura tiene elementos de diferentes tipos y longitudes, en C usamos struct para definir estructuras. El modificador const hace que nuestra estructura sea almacenada en la RAM, si obviamos este modificador nuestra estructura será ubicada en la RAM donde la podremos modificar dinámicamente.
El modo de crear estructuras es la siguiente:
struct player{
unsigned char Xpos; // primer elemento
unsigned char Ypos; // segundo elemento
unsigned short Score; // tercer elemento
};
typedef struct player playerType;
El comando typedef crea un tipo de dato basado en la estructura.
Ahora crearemos una variable basado en nuestra estructura.
playerType P1;
Podemos accesar y almacenar valores en nuestra nueva variable de la siguiente forma:
P1.Xpos = 12;
P1.Ypos = 14;
P1.Score = 100;
También podemos crear variables tipo array de la siguiente manera:
playerType autos[4];
Ahora por ejemplo para poder cambiar la variable podemos realizar una función.
void cambiar(char i, char a, char b){
auto[i].Xpos = a;
auto[i].Ypos = b;
}
Arrays:
Cuando necesitamos asignar un lugar en donde colocar datos, una de las maneras más simples y fáciles es almacenarlas en la memoria RAM, y si los datos que almacenamos son constantes al momento de la compilación podemos almacenarlos en la memoria ROM.
Acceso aleatorio significa que podemos leer o escribir cualquier elemento en cualquier orden, el acceso aleatorio esta permitido para todas las estructuras de datos indexables. Una estructura de datos indexable contiene elementos del mismo tamaño y puede ser accesada mediante el nombre de la estructura, el tamaño del elemento y el número de elemento.
Un array esta hecho de elementos de igual tamaño y permite acceso aleatorio, el largo del array es el número de elementos, el origen esta indexado al primer elemento, por ejemplo Dato[0] es el primer elemento del array Dato.
Al igual que cualquier variable, un array tiene que ser declarado antes de accesarlo, el número de elementos en el array es determinado cuando se declara. Arrays multidimensionales requieren ser declarados con varios brackets ‘[ ]’.
short Dato[4]; //Array de 4 espacios para enteros de 16 bits
char Imagen[3][4]; //Array de 34 = 12 espacios para enteros de 8 bits int Puntos[2][4][3]; //Array de 24*3 = 24 espacios
Si queremos inicar los arrays con valores diferentes de cero entonces colocamos los datos de la siguiente manera:
short Dato[4] = {1, 2, 3, 4};
char Imagen[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
int Puntos[2][4][6] = {
{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}},
{{13, 14, 15}, {16, 17, 18}, {19, 20, 21}, {22, 23, 24}}
};
Para modificar los valores del array:
Dato[2] = 10; //El array queda {1, 2, 10, 4}
Para obtener datos del array:
Variable = Dato[3] //Variable ahora tiene el valor 4
Para colocar arrays con valores contantes invariables, colocamos const al inicio de la declaración, de esta forma nuestro array sera colocado en la ROM.
const short Dato[4] = {1, 2, 3, 4};
En el uso de funciones también podemos usar arrays, por ejemplo hallemos el valor máximo de un conjunto de datos almacenados en el array class.
long Maximo(long class[], long tamaño){
long largo,i;
largo = 0;
for(i=0; i largo){
largo = class[i]; // Nuevo máximo
}
}
return (largo);
}