Mensajes

Me alegro que te sirviese!! Cada vez que se se te resuelva una duda, marca el hilo como que ya ha sido respondida tu duda

[Como puedes ver,lo que almacena en realidad nuestro arreglo, es donde se encuentran los datos del arreglo]

Como se ha dicho en este hilo, un arreglo, es decir, un puntero, apunta hacia una dirección de memoria. Ahora bien, en en caso de los arreglos, pasa lo siguiente:

Pongamos este ejemplo:

Código (cpp) [Seleccionar] Expandir

#include <iostream>

int main() {
        int valor[4] = {2, 3, 1, 4};

        std::cout << valor[0] << std::endl;
       
        std::cin.get();
        return 0;
}

En este caso, hemos declarado e inicializado un arregle de 4 elementos. Aunque tu veas el arreglo así, en realidad lo que almacena 'valor' es una dirección que apunta al primer byte de ese arreglo:



Como puedes ver,lo que almacena en realidad nuestro arreglo, es donde se encuentran los datos del arreglo

Entonces, volviendo al tema, lo que le debes pasar a scanf es DONDE quieres que guarde lo que ha leido de la consola, entonces debes pasarle LA DIRECCION DEL ELEMENTO DEL ARRAY QUE LE QUIERES PASAR. Para hacer esto, primero debes indicar que elemento quieres cambiar (lo cual se hace con los corchetes []), y después debes pasarle donde está ese elemento, con el operador &.

Entonces, en resumidas cuentas, lo que hace este programa es acceder a los elementos del arreglo por orden, porque la variable 'i' va tomando valores desde 0 hasta 4

En primer lugar, ¿el tamaño de la matriz está predefinido? ¿Tiene que ser cuadrada (2x2, 3x3...), o cuando te pida el determinante de la matriz no cuadrada te tiene que dar error?. Si la matriz es de un tamaño fijo, lo que tienes que hacer es guardar esa matriz como privada en la clase, tal que así:

Código (cpp) [Seleccionar] Expandir

class Matriz {
             public:
                   Matriz();

                   int get_Size();
                   int get_Determ();
                   int get_Unos();
                   int get_Zeros();
                   int get_Identidad();

             private:
                   float matriz[3][3];

};

Entonces, a la hora de pasarle el orden, le pasarías 3 (es una matriz 3x3), en el caso del determinante, supondré que sabes como hacer un determinante. En el caso de rellenar, es sencillo (es asignar a cada calor de 'matriz' sus respectivos ceros o unos. Lo mismo en el caso de generar la matriz identidad

Para que sirven los operadores ">>" y el operador "&" (este último lo había visto pero solo como "&&")

*El operador >> sirve para lo que se denomina 'Desplazamiento de Bits' Esto sirve para lo que su nombre dice. Me explico con un ejemplo: tenemos una variable de tipo entero (int) cuyo valor es 12. Dicho numero en binario es 1100. Si hacemos la siguiente operación...

Código (cpp) [Seleccionar] Expandir

varialbe = variable >> 1
entonces estamos desplazando todos los bits un lugar, dando como resultado el numero en binario 0110. El 1 que estaba en cuarto lugar ha pasado al tercer lugar. El 1 que estaba en tercer lugar ha pasado al segundo lugar... y así sucesivamente. Si hubiéramos hecho esto...

Código (cpp) [Seleccionar] Expandir

variable = variable >> 2
entonces daría como resultado 0011 en binario

*El operador & es parecido al |. Lo que hace es multiplicar bit a bit dos valores. Por ejemplo, tenemos los valores 011010 y 110011 (en binario). Si hacemos 011010 & 110011 obtendremos 010010.
Empezamos de derecha a izquierda: El primer bit está determinado por la operación 1 * 0, por lo que vale 0. El segundo bit está determinado por la operación 1 * 1, por lo que vale 1 y así sucesivamente

Mira, imagínate que asignamos a dos propiedades diferentes dos ID diferentes:
*A la propiedad de que la ventana debe estar en pantalla completa le asignamos la ID 01 (Está en binario)
*A la propiedad de que la ventana tenga bordes le asignamos la ID 10.

Entonces, si le pasamos la propiedad de pantalla completa solamente, le pasaremos 01. Si le pasamos solamente la propiedad de que la ventana tenga bordes, le pasamos 10, y si queremos que tenga ambas propiedades, le pasamos 01 | 10, es decir, 11.

Dicho de otra forma, a cada propiedad le asignamos una posición en una variable. En el caso anterior, solamente caben 2 propiedades como máximo, puesto que solo hay dos posiciones, es decir, 2 bits. A la posicion 1 le asigné la propiedad de pantalla completa, si vale 0, entonces estará en modo ventana y si vale 1 estará en pantalla completa, y lo mismo con la ventana con bordes. Si la segunda posición vale 0, entonces la ventana no tendrá bordes, y viceversa.

En Windows, es muy común usar estos operadores para crear flags. Me explico: Al crear una ventana, tu le tienes que pasar una serie de caracteristicas a dicha ventana (por ejemplo, ¿tendrá borde mi ventana?, ¿será en pantalla completa?, etc). Para pasarle estas propiedades a Windows, se usan los ya mencionados, los Flags (en español banderas)

Agunas propiedades son:
WS_VISIBLE = 10000000000000000000000000000 en binario (Define si una ventana es visible)
WS_VSCROLL= 00000001000000000000000000000 en binario (Define si una ventana tendrá una barra de desplazamiento vertical)

Entonces, si le quieres pasar esos dos parametros juntos a Windows, haces lo siguiente:

WS_VISIBLE | WS_VSCROLL, lo cual dará como resultado:
10000001000000000000000000000

Como ves, hemos conseguido fusionar las dos propiedades en una sin perder información.

Espero que se haya entendido

Para dejar mi miga de pan, os dejo un simple ejemplo de como generar el diccionario y a su vez guardarlo en un archivo:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>

int main() {
FILE * lpstFilePointer = NULL;
char lpszFilePath[256];
char *lpString = NULL;
int nNumCharacters = 0;

std::cout << "Cuantos caracteres necesitas? ";
std::cin >> nNumCharacters;

std::cout << "Donde deseas guardar los datos? ";
std::cin >> lpszFilePath;

lpstFilePointer = fopen((const char *)lpszFilePath, "w");

if(lpstFilePointer == NULL) {
std::cout << "Error al abrir el archivo en la ruta '" << lpszFilePath << "'. El programa se va a cerrar";
std::cin.get();
return 1;
}

lpString = new char[nNumCharacters];

if(lpString == NULL) {
std::cout << "Error al declarar la cadena temporal para generar el diccionario.";
std::cin.get();
return 1;
}

for(int i = 0; i <= (int)pow(26, nNumCharacters); i++) {
itoa(i, lpString, 26);

for(int e = 0; e < nNumCharacters; e++) {
if(lpString[e] != 0) {
if(lpString[e] <= 57)
lpString[e] += 49;
else
lpString[e] += 10;
}
}

fputs(lpString, lpstFilePointer);
fputc('\n', lpstFilePointer);
}

std::cout << "El programa ha finalizado el proceso.";
fclose(lpstFilePointer);
std::cin.get();
return 0;
}

¿Lo que quieres es saber cuántas veces se repite UNA palabra, o cuántas veces se repite cada palabra del archivo?

En el caso de que sea la primera opción, aquí te dejo un ejemplo:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main () {
char lpszText[] = "Esto es el texto que incluye el archivo. Esto no son datos reales Jaja";
char lpszWordToBeChecked[256] = ""; // Contendrá la palabra a ser comparada
char *lpszWord; // Contendrá las palabras leidas (solo una por ciclo)
unsigned int uRepeatedTimes = 0; // Numero de veces que se ha repetido la palabra
unsigned int nCounter = 0; // Contador usados en los ciclos 'for'

printf("Introduzca la palabra que desea que comparemos: ");
scanf("%s", lpszWordToBeChecked);

for(nCounter = 0; lpszWordToBeChecked[nCounter] != 0; nCounter++) { // Convertimos la palabra a ser comparada a minusculas para así poder comparar las cadenas
if(lpszWordToBeChecked[nCounter] >= 65 && lpszWordToBeChecked[nCounter] <= 90)
lpszWordToBeChecked[nCounter] += 32;
}

lpszWord = strtok(lpszText, " ,:.;-_123456789<>(){}/\\\""); // Tomamos una palabra de la cadena. El segundo parámetro contiene los caracteres que no forman una palabra

while(lpszWord != 0) {
for(nCounter = 0; lpszWord[nCounter] != 0; nCounter++) { // A minusculas (para poder comparar las cadenas)
if(lpszWord[nCounter] >= 65 && lpszWord[nCounter] <= 90)
lpszWord[nCounter] += 32;
}

if(strcmp(lpszWord, lpszWordToBeChecked) == 0) // Comparamos la cadena
uRepeatedTimes++;

lpszWord = strtok(NULL, " ,:.;-_123456789<>(){}/\\\""); // Tomamos la siguiente palabra de la cadena
}

printf("Las veces que se ha repetido la palabra '%s' son: %u", lpszWordToBeChecked, uRepeatedTimes); // Imprimimos el resultado final!

return 0;
}

PD.: USA LAS ETIQUETAS GeSHI!!

¿A que viene esto? XD

Código (cpp) [Seleccionar] Expandir

1*0==0;
0*0==0;
0*1==0;
1*1==1;

Después de que se active el switch con el case 1 (el de las drogas), el programa muestra un mensaje en pantalla. Después de mostrar el mensaje, como has puesto un break, se sale del switch. Después del switch hay un 'return 0;. Cuando la función main retorna, el programa se cierra. Para solucionar esto, después del switch pon (si trabajas en Windows) system("pause");, o puedes usar getc. Eso ya es elección tuya