Mensajes

size_t es un alias. Estos alias se utilizan para abstraer al código de la utilización de un tipo de dato concreto.

las librerías que tu usas para compilar definen size_t de la siguiente forma:

Código (c) [Seleccionar] Expandir

typedef unsigned int size_t;

Pero en otras arquitecturas ( 8 bits, 16 bits, ... ) no tiene por qué estar definido size_t de la misma forma, ya que en esos entornos es posible que unsigned int no sea el tipo de dato más adecuado.

size_t, al igual que otros tantos alias definidos en la librería estándar, se usa para dotar de cierta independencia al código con respecto a la arquitectura sobre la que va a correr el código. La idea es que el código sea lo más portable posible.

El código siguiente crea un objeto llamado "Deportes" que va a ser un contenedor de tipo "vector", dicho contenedor va a almacenar elementos de tipo "Categorias".

Código (cpp) [Seleccionar] Expandir

vector< Categorias > Deportes;

Los contenedores son objetos de c++, como la clase string que ya has usado. Tienen su propio conjunto de métodos y sirven para almacenar colecciones de elementos, en tu caso un array de Categorias.

"vector" es un contenedor que se caracteriza porque los elementos que contiene mantienen el orden en el que fueron insertados, es decir, no ordena los objetos que contiene ( eso lo hace otro contenedor llamado "set" ).

El método "push_back" del vector añade un elemento al vector colocándolo al final de la lista.

La forma de acceder a los elementos de "vector" es la misma que para un array clásico de c, es decir, usando los corchetes. Esto es posible porque "vector" sobrecarga el operador de índice ( esto ya lo aprenderás en el futuro ).

Mejor así?

Claro, strlen(); pretende ser una función universal estándar, la mía es una implementación casera ya tuve en cuenta el problema del límite de almacenamiento de unsigned char, por eso el array de caracteres que se toma del usuario es de 140 huecos. (suficiente para algo rapidillo, pero modificaré el código).

Gracias por la explicación del error del 32, ahora lo corrijo.

El problema que tiene unsigned char para cosas como estas es que si superas los 255 caracteres volverás a empezar por el cero ( 255 + 1 = 0 ) y la función no terminará nunca, entrarás en un bucle infinito.

Esto se hace con vectores.

Código (cpp) [Seleccionar] Expandir


#include <vector>

void Ingresar_Deportista ( vector< Categorias >& Deportes );

int main(int argc, char *argv[])
{  
   int Num_Deportes=1; //Tamaño Variable - Cambia En Tiempo De Ejecucion
   vector< Categorias > Deportes;

   Ingresar_Deportista( Deportes );
   
   system("PAUSE");
   return EXIT_SUCCESS;
}

void Ingresar_Deportista ( vector< Categorias >& Deportes )
{
    int i=0, Aux=0;
    char Opcion='s';
   
    while(Opcion=='s'){
      Categorias categoria;

    cout<<"Deporte: ";
    cin>>categoria.Deporte;
    cout<<"\nNombre: ";
    cin>>categoria.Informacion.Nombre;
    cout<<"Edad: ";
    cin>>categoria.Informacion.Edad;

    Deportes.push_back( categoria );

    cout<<"\nIngresar Mas? Si(s) ";
    Opcion=getch();
    i+=1;
    system("cls");
   
    }
}

c++ tiene muchas clases útiles, es bastante importante conocer al menos las más importantes y, los contenedores ( vector, set, map, etc. ) son básicas.

Entre otras cosas gestionar tu esa memoria implica varios problemas. Por ejemplo para el que te ocupaba lo que tenías que hacer era crear un array nuevo, copiar el contenido del vector viejo en el nuevo, hacer que el puntero del vector viejo apuntase al nuevo y, finalmente, eliminar el vector viejo... demasiado curro innecesario.

No me tomé a mal tu comentario, simplemente me intenté explicar, muchas gracias por la información a cerca de las variables static, es un modificador que no suelo usar porque no se mucho de él, al fin y al cabo fallando se aprende, ya he modificado el código para solventar el error.

Por cierto, no entendí la solución que me ofreciste para lo del 32, te referías a sumar tal que así:

Código (cpp) [Seleccionar] Expandir

texto[contador] += 'A';

Pregunto.

Mas bien me refería a esto para pasar a mayúsculas:

Código (c) [Seleccionar] Expandir

texto[contador] -= 'a' - 'A';

y esto para pasar a minúsculas:

Código (c) [Seleccionar] Expandir

texto[contador] += 'a' - 'A';

La lógica que está detrás de esto es que el ordenador solo entiende de información binaria, es decir, de números. Un carácter no es más que la conversión de un número de 8 bits en un carácter imprimible. el carácter 'A' se corresponde en ascii con el número 65 y el 'a' con el 97. Si haces la resta da 32 que es el número que tú has puesto directamente en el código.

Obviamente que en la librería estándar de C y C++ han metido la mano ingenieros con mucha más preparación que yo, no pretendo superarles ni mucho menos, todavía estoy aprendiendo.

No, la función magnitudTexto(); no añade nada a la función strlen(); de string.h pero en muchas universidades (todavía no estoy en esa edad) tengo constancia de que piden a modo de ejercicio para familiarizarse con eso de los algoritmos y demás hacer implementaciones propias de algunas funciones de la librería stándar (he aquí la mía a modo de aporte).

No te lo tomes a mal, no te estoy quitando el mérito. Simplemente he leído tu mensaje y visto tu código y he contestado en consecuencia. No conozco los detalles particulares y personales que te han llevado a escribir el mensaje.

En cuanto a las otras dos funciones son diferentes de toupper(); y tolower(); en el sentido en que estas dos funciones estándar trabajan con caracteres individuales, teniendo que hacer tú mismo el bucle correspondiente para pasar una cadena entera a mayúsculas o minúsculas. Las funciones de mi aporte no tienen sustituto en el estándar.

Lo de las funciones toupper y tolower es cierto, de hecho mi único comentario acerca de tus funciones sustitutas es que poner a pelo un '32' no es la mejor opción. Eso y lo de las variables estáticas que no tiene ningún sentido.

Una de las razones por la que me registré en el foro fue para aprender, por tanto gracias por tu consejo sobre las variables estáticas de las que no se mucho aunque tengo entendido que si uno llama en sucesivas ocasiones a una función al ser la variable estática sólo se inicializa una vez, mejorando el rendimiento del programa. Me gustaría saber más sobre el tema, al igual que de programación multihilo de la que sólo he tocado un poco en Java.

Te explico un poco acerca de las variables estáticas.

Imagina que quieres una función que vaya sumando valores y te retorne el resultado. Una primera versión de dicha función podría quedar tal que:

Código (c) [Seleccionar] Expandir

int sumador(int valor)
{
    int total += valor;
    return total;
}

Al ejecutar esto te das cuenta de que SIEMPRE te va a devolver lo mismo que le pases como parámetro, no va a sumar nada y, en resumen, no funciona.

Aquí entran en juego las variables estáticas. Las variables estáticas no pierden su significado al salirse de su ámbito ( esto te toca mirarlo en internet si no sabes qué es que si no me enrollo demasiado ), sino que mantienen su identidad durante la ejecución de la aplicación.

Haciendo un par de cambios conseguimos que la función cumpla su cometido:

Código (c) [Seleccionar] Expandir

int sumador( int valor )
{
    static int total = 0;
    total += valor;
    return total;
}

El asignarle un valor al declarar la variable es algo que sólo se ejecutará la primera vez que se llame al código, el resto del tiempo la variable 'total' recordará el valor que se le asignó la última vez y el sumador funcionará correctamente.

El problema que tienen las variables estáticas en entornos multihilo es que si yo llamo a sumador a la vez desde dos hilos diferentes, al compartirse entre ambos el valor de la variable estática, el resultado va a ser incorrecto porque las instrucciones se van a pisar entre si.

No lo tomes a mal, pero no veo que beneficios aporta la función "magnitudTexto" sobre la función strlen. Además tampoco entiendo por qué razón la variable "magnitud" tiene que ser estática... esto en un entorno multihilo da problemas.

En cuanto a las otras dos no creo que tu implementación esté más optimizada que la proporcionada por la librería estándar, donde ha metido mano gente que desde luego era más lista que tu y que yo.

Las funciones de conversión, en vez de sumar y restar por 32 ( difícil de entender a primera vista ), sería más lógico que lo indicases como 'a' - 'A'. Es lo mismo pero la segunda opción es más gráfica y el compilador genera exactamente el mismo código al optimizar.

En el caso de las variables estáticas en las funciones de conversión te digo lo mismo, no tienen sentido y no funcionan en entornos multihilo.

Esto ahora tiene mucha mejor pinta que la primera versión que pusiste por aquí hace dos o tres meses...

enhorabuena

Si bien puedes utilizar estrategias tipo Trie, para el problema que planteas la manera más sencilla es la que te han comentado, leer primero todo el diccionario de palabras en el que buscas, ordenarlo y por cada palabra que busques hacer una búsqueda binaria. A la hora de implementarlo, lo más sencillo es que metas dichas palabras en un set de C++ y utilices la función count o find para saber si están o no.

Si optaras por utilizar estructuras tipo Trie, lo más eficiente sería utilizar o bien una estrategia de preprocesado del texto vía Suffix Tree (muy difícil de implementar siendo eficiente) o bien preprocesar los patrones a buscar vía Aho-Corasick (algo menos difícil que un Suffix Tree a mi opinión, pero también muy difícil). Sinceramente el tiempo de ejecución que vas a ganar con estas opciones para un diccionario de 70000 palabras es bastante despreciable, así que yo optaría por la binaria, que con un set son 5 líneas.

Falta decir que con set no hace falta ordenar las palabras previamente ya que set, por definición, es una lista ordenada.

Muy sencillo no podes enviar punteros ... hace una copia de los datos y envialos. En otra maquina (incluso en otro proceso) el espacio de memoria es totalmente independiente asi que el puntero es invalido o peor, apunta a otra cosa ...

Exacto.

Para gestionar este tipo de cosas puedes emplear mecanismos estándares de serialización ya existentes ( ASN1, JSON, Protocol Buffers, XDR, ... ). Si bien te exigen algo más de trabajo a la hora de enviar y recibir datos, lo cierto es que te simplifican enormemente la tarea de gestionar lo que se envía... además de que proporcionan mecanismos para permitir la comunicación entre máquinas con diferentes arquitecturas ( 32 bits - 64 bits, big endian - little endian, ... )