Update PEC3
This commit is contained in:
parent
b010e93505
commit
bcb7577058
@ -11,6 +11,7 @@
|
||||
- [6.1.2. Representación de memoria](#612-representación-de-memoria)
|
||||
- [6.1.3. Inicialización](#613-inicialización)
|
||||
- [6.2. Matrices](#62-matrices)
|
||||
- [6.3. Ejemplos](#63-ejemplos)
|
||||
- [7. Cambio de tipos de datos en C](#7-cambio-de-tipos-de-datos-en-c)
|
||||
- [7.1. Reglas de coneversión](#71-reglas-de-coneversión)
|
||||
- [7.2. Cambio explícito de tipos de datos](#72-cambio-explícito-de-tipos-de-datos)
|
||||
@ -313,13 +314,250 @@ Con los strings podemos utilizar los mismos operadores externos que con los cara
|
||||
|
||||
#### 6.1.2. Representación de memoria
|
||||
|
||||
Todas las posiciones de un vector se guardan en memoria consecutivamente. La dirección de memoria de la primera posición del vector es la dirección de memoria de la variable que lo contiene.
|
||||
|
||||
#### 6.1.3. Inicialización
|
||||
|
||||
Como buena práctica, primero definimos el vector especificando su tamaño máximo y después lo inicializamos.
|
||||
|
||||
```c
|
||||
algorithm vectors
|
||||
var
|
||||
v1 : vector[3] of integer;
|
||||
v2 : vector[4] of integer;
|
||||
end var
|
||||
v1[1] := 3;
|
||||
v1[2] := 5;
|
||||
v1[3] := -1;
|
||||
v2[1] := 3;
|
||||
v2[2] := 5;
|
||||
v2[3] := -1;
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
/* Variable definition*/
|
||||
int v1[3];
|
||||
int v2[4];
|
||||
v1[0] = 3;
|
||||
v1[1] = 5;
|
||||
v1[2] = -1;
|
||||
v2[0] = 3;
|
||||
v2[1] = 5;
|
||||
v2[2] = -1;
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
En el caso de v2, es un vector de 4 posiciones del que solo inicializamos las 3 primeras.
|
||||
|
||||
En el caso de las cadenas de caracteres, podemos utilizar las comillas dobles ("), o tratarlo igual que un vector
|
||||
normal y asignar carácter a carácter. A continuación se muestra un ejemplo donde, para cada string, se muestra
|
||||
su contenido, el tamaño en bytes y la cantidad de caracteres (se contabilizan hasta encontrar el símbolo de final
|
||||
de cadena '\0')
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
char a[4];
|
||||
char b[5];
|
||||
char c[4];
|
||||
char d[5];
|
||||
a[0] = 'a';
|
||||
a[1] = 'b';
|
||||
a[2] = 'c';
|
||||
a[3] = '\0';
|
||||
b[0] = 'a';
|
||||
b[1] = 'b';
|
||||
b[2] = 'c';
|
||||
b[3] = '\0';
|
||||
strcpy(c, "abc");
|
||||
strcpy(d, "abc");
|
||||
printf("a - %s --> (%d) bytes, (%d) chars\n", a, sizeof(a), strlen(a));
|
||||
printf("b - %s --> (%d) bytes, (%d) chars\n", b, sizeof(b), strlen(b));
|
||||
printf("c - %s --> (%d) bytes, (%d) chars\n", c, sizeof(c), strlen(c));
|
||||
printf("d - %s --> (%d) bytes, (%d) chars\n", d, sizeof(d), strlen(d));
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### 6.2. Matrices
|
||||
|
||||
Las matrices son vectores de dos dimensiones. Se pueden definir como un vector de vectores.
|
||||
|
||||
```c
|
||||
algorithm matrix
|
||||
var
|
||||
m : vector[2][3] of integer;
|
||||
end var
|
||||
m[1][1] := 1;
|
||||
m[1][2] := 2;
|
||||
m[1][3] := 3;
|
||||
m[2][1] := 4;
|
||||
m[2][2] := 5;
|
||||
m[2][3] := 6;
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
/* Variable definition*/
|
||||
int m[2][3];
|
||||
m[0][0] = 1;
|
||||
m[0][1] = 2;
|
||||
m[0][2] = 3;
|
||||
m[1][0] = 4;
|
||||
m[1][1] = 5;
|
||||
m[1][2] = 6;
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Primero se declara el número de filas y luego el de columnas.
|
||||
|
||||
Igual que en el caso de los vectores unidimensionales, con los de n-dimensiones el índice de las posiciones empieza por 1 con lenguaje algorítmico, y por 0 con lenguaje C.
|
||||
|
||||
Ejemplo que calcula el valor promedio de todos los valores de la matriz anterior:
|
||||
|
||||
```c
|
||||
algorithm matAverage
|
||||
var
|
||||
m : vector[2][3] of integer;
|
||||
r : real;
|
||||
end var
|
||||
m[1][1] := 1;
|
||||
m[1][2] := 2;
|
||||
m[1][3] := 3;
|
||||
m[2][1] := 4;
|
||||
m[2][2] := 5;
|
||||
m[2][3] := 6;
|
||||
r := integerToReal(m[1][1] + m[1][2] + m[1][3] + m[2][1] + m[2][2] + m[2][3]);
|
||||
r := r/6.0;
|
||||
writeReal(r);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
/* Variable definition*/
|
||||
int m[2][3];
|
||||
float r;
|
||||
m[0][0] = 1;
|
||||
m[0][1] = 2;
|
||||
m[0][2] = 3;
|
||||
m[1][0] = 4;
|
||||
m[1][1] = 5;
|
||||
m[1][2] = 6;
|
||||
r = (m[0][0] + m[0][1] + m[0][2] + m[1][0] + m[1][1] + m[1][2]) / 6.0;
|
||||
printf("%f\n", r);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Cuando se guarda en memoria, se hace por filas. Por tanto, una matriz como la anterior en memoria es equivalente a un vector de 2x3 = 6 posiciones y por tanto de 6x4 = 24 bytes.
|
||||
|
||||
|
||||
### 6.3. Ejemplos
|
||||
|
||||
Algoritmo que calcule el producto escalar de dos vectores en un espacio de dos dimensiones (2D)
|
||||
|
||||
```c
|
||||
algorithm dotProduct
|
||||
var
|
||||
a : vector[2] of integer;
|
||||
b : vector[2] of integer;
|
||||
c : integer;
|
||||
end var
|
||||
a[1] := readInteger();
|
||||
a[2] := readInteger();
|
||||
b[1] := readInteger();
|
||||
b[2] := readInteger();
|
||||
c := a[1] * b[1] + a[2] * b[2];
|
||||
writeInteger(c);
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
/* Variable definition*/
|
||||
int a[2], b[2];
|
||||
int c;
|
||||
scanf("%d", &a[0]);
|
||||
scanf("%d", &a[1]);
|
||||
scanf("%d", &b[0]);
|
||||
scanf("%d", &b[1]);
|
||||
c = a[0] * b[0] + a[1] * b[1];
|
||||
printf("(%d,%d) * (%d,%d) = %d\n", a[0], a[1], b[0], b[1], c);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
Algoritmo que calcule el producto entre la matriz identidad de 3x3 y un valor entero introducido por
|
||||
teclado.
|
||||
|
||||
```c
|
||||
algorithm dotProduct
|
||||
var
|
||||
id : vector[3][3] of integer;
|
||||
s : integer;
|
||||
r : vector[3][3] of integer;
|
||||
end var
|
||||
id[1][1] := 1;
|
||||
id[1][2] := 0;
|
||||
id[1][3] := 0;
|
||||
id[2][1] := 0;
|
||||
id[2][2] := 1;
|
||||
id[2][3] := 0;
|
||||
id[3][1] := 0;
|
||||
id[3][2] := 0;
|
||||
id[3][3] := 1;
|
||||
s := readInteger();
|
||||
r[1][1] := id[1][1] * s;
|
||||
r[1][2] := id[1][2] * s;
|
||||
r[1][3] := id[1][3] * s;
|
||||
r[2][1] := id[2][1] * s;
|
||||
r[2][2] := id[2][2] * s;
|
||||
r[2][3] := id[2][3] * s;
|
||||
r[3][1] := id[3][1] * s;
|
||||
r[3][2] := id[3][2] * s;
|
||||
r[3][3] := id[3][3] * s;
|
||||
end algorithm
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
/* Variable definition*/
|
||||
int id[3][3];
|
||||
int s;
|
||||
int r[3][3];
|
||||
id[0][0] = 1;
|
||||
id[0][1] = 0;
|
||||
id[0][2] = 0;
|
||||
id[1][0] = 0;
|
||||
id[1][1] = 1;
|
||||
id[1][2] = 0;
|
||||
id[2][0] = 0;
|
||||
id[2][1] = 0;
|
||||
id[2][2] = 1;
|
||||
scanf("%d", &s);
|
||||
r[0][0] = id[0][0] * s;
|
||||
r[0][1] = id[0][1] * s;
|
||||
r[0][2] = id[0][2] * s;
|
||||
r[1][0] = id[1][0] * s;
|
||||
r[1][1] = id[1][1] * s;
|
||||
r[1][2] = id[1][2] * s;
|
||||
r[2][0] = id[2][0] * s;
|
||||
r[2][1] = id[2][1] * s;
|
||||
r[2][2] = id[2][2] * s;
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## 7. Cambio de tipos de datos en C
|
||||
|
||||
Loading…
Reference in New Issue
Block a user