Foro de elhacker.net

Hola!
Estoy haciendo un programa en el que uso void y arrays, y no se por que en cuanto llego a un void el array cambia de tamaño  :huh:
Este es el punto deonde me da problemas:

const int tamaño = 4;
 
typedef int tCode[tamaño];
 
void codigoAleatorio(tCode code) {    //Aqui cambia a ser code ={0} en vez de code = {0,0,0,0}
	int random = 0;
	srand(time(NULL));
	for (int i = 0; i < TAM_CODIGO; i++) {
		random = rand() % 7;
		code[i] = random; (aqui no se por que no salen [] con la i dentro despues de code)
	}
}
 
el main esta asi:
int main(){
     tCode code = {};
      /*funcion*/
 }

alguna idea?
Gracias.

porque debes usar las etiquetas GeSHi, si no [ i ] significa cursiva, porfa corrige tu codigo para ver bien el problema y en el main si es posble pon más codigo relacionado

vale, gracias.
Este es mi main:

int main() {
	int opcion = menu();
	EjecutarMenu(opcion);
	return 0;
}
int EjecutarMenu(int opcion) {
	tCodigo codigo = {};
	tCodigo hipotesis = {};
	bool admiteRepetidos = false;
	int colocados = 0, descolocados = 0;
	while (opcion != 0) {
		switch (opcion) {
		case (1): {//funcion no repetidos
			opcion1(codigo, hipotesis, admiteRepetidos, colocados, descolocados);
		}
				  break;
		case (2): {//funcion con repetidos
			opcion2(codigo, hipotesis, admiteRepetidos, colocados, descolocados);
		}
				  break;
		}
	}
	return opcion;
}

las funciones opcion1 y opcion2 son dos void bastante parecidos y en cuanto llega al void cambia el  tamaño del array.

void opcion1(tCodigo codigo, tCodigo hipotesis, bool admiteRepetidos, int colocados, int descolocados) {
	admiteRepetidos = false;
	codigoAleatorio(codigo, admiteRepetidos);
	cout << "Introduce el codigo (palabra de 4 letras con alguna de las siguientes, R, Z, V, A, M, B): ";
	for (int s = 0; s < TAM_CODIGO - 1; s++)
		cin >> hipotesis[s];
	compararCodigos(codigo, hipotesis, colocados, descolocados);
	ImprimirPantalla(codigo, hipotesis, colocados, descolocados);
	while (colocados != TAM_CODIGO)
		cout << "Introduce el codigo (palabra de 4 letras con alguna de las siguientes, R, Z, V, A, M, B): ";
	for (int s = 0; s < TAM_CODIGO - 1; s++)
		cin >> hipotesis[s];
	compararCodigos(codigo, hipotesis, colocados, descolocados);
	ImprimirPantalla(codigo, hipotesis, colocados, descolocados);
}

Tienes algunos fallos que atribuyó a que aunque no conoces del todo el lenguaje y buenas prácticas, pero me gustaría que explicarás en qué notas que el array cambia el tamaño.
Lo que si he observado es que haces cosas así:


TAM_CODIGO marca el número de elementos, como C empieza por el 0 el máximo índice será TAM_CODIGO -1, y precisamente ese es al que va a llegar el for con la sentencia s<TAM_CODIGO: mientras s esté por debajo de TAM_CODIGO se va a ejecutar su código asociado. Pero tú le restas 1 a TAM_CODIGO con lo que no ejecutará las veces suficientes el código asociado, te faltará una. Tal vez eso es lo que te pasa.

es que comparo dos cosas en las posiciones del array, entonces no quiero que se salga del array (comparar el ultimo elemento del array con la nada), el ultimo elemento de array solo se compara con su anterior, entonces x solo puede llegar a valer como maximo 3. Pero el problema es que en cuanto pasa a un void, el array cambia automaticamente de tamaño, en vez de seguir siendo de tamaño cuatro, pasa a ser de tamaño 1.

ahi dejo una captura de como se cambia el solito
https://gyazo.com/3643d198efb64fb42a8b85c5cb4c50bf (https://gyazo.com/3643d198efb64fb42a8b85c5cb4c50bf)
https://gyazo.com/072244555cacd0ef0a6fb45f4a39485b (https://gyazo.com/072244555cacd0ef0a6fb45f4a39485b)

Vale. El void no es lo que pasas sino el tipo de dato devuelto de la función. Por otra parte te diría que mires un paper de lo que ocurre cuando se usa un array como argumento.

A grandes rasgos un array de una dimensión es lo mismo que un puntero, solo se pasará la dirección del primer elemento, todos los demás 'adornos' como el tipo de dato del array y loas restantes dimensiones que pueda tener (se especifican todas las dimensiones de un array menos la de más a la izquierda) solo sirven para, internamente, hacer aritmética y encontrar el dato deseado cuando usas notación de array.

Por tanto un array, cuando es pasado a una función, pierde toda la información de su tamaño y, a ojos del compilador, es un puntero.

entonces como puedo hacerlo?
por que me piden que lo haga asi (es un trabajo de clase) y por narices tengo que usar voids,de hecho me ponen algunos asi:

void codigoAleatorio(tCodigo codigo, bool admiteRepetidos);

y tengo que rellenarlos, otros solo me dan el nombre de la funcion.
y los que me dan "completos" no puedo modificarlos
asi que por ejemplo no puedo ponerle :

void codigoAleatorio(const tCodigo codigo, bool admiteReetidos);

Olvídate del void. En este caso indica que la función no devuelve ningún valor, solo hace un trabajo (en otros lenguajes se llamaría procedimiento o subprograma).

Cuando se pasa un array a una función lo normal es pasar también el número de elementos que el array contiene en otro argumento y así la función conocerá el límite. De todas formas tú usas una variación de eso qué es mediante una variable global llamada TAM_CODIGO, que por otra parte, en el primer código que has mostrado la llamas 'tamaño'.

Es decir, dentro de la función debes olvidarte del tamaño del array, lo verás como si fuera un puntero (o un entero sin signo, por si no has llegado a los punteros) y usa para trabajar con él los límites, ya sean variables globales o argumentos que lo van a acompañar en las llamadas a funciones.

entonces a la vuelta de vacaciones tendre que hablar con el profesor, por que quiere que use esa funcion y que haga algo determinado y no me puedo salir del guion...
Gracias por la ayuda

¿Exactamente qué te pide exactamente?

void codigoAleatorio(tCodigo codigo, bool admiteRepetidos): elige
aleatoriamente un código y lo devuelve con el parámetro de salida. El
segundo parámetro permite indicar si se admiten colores repetidos en él.

para eso nos dio tambien como hacer  una funcion que genere numeros aleatorios y con esa funcion rellenamos el array dentro del void.

Bien.
Mira:
Lo primero de todo, para entender lo que debes hacer es entender qué te pide la función, así que voy a desglosarla:
void: Como te he dicho indica que la función no retorna valor alguno, solo realiza un trabajo.
codigoAleatorio: Tú dices que debe generar un código aleatorio en el array que se le va a pasar. De ahí que tenga ese nombre.
tCodigo codigo: Es el array que le pasarás a esta función. Ahora algo que seguramente no has visto: Los arrays y punteros se dice que se pasan por referencia, es decir, ese dato se podrá cambiar. El funcionamiento interno es un poco más complicado, pero por ahora te basta saber eso. Así es como la función retornará el array relleno.
bool admiteRepetidos: Dato que indicará si se pueden repetir los elementos.

Como puedes ver no hay ningún argumento que diga el tamaño que tendrá el array, así que lo deberás tomar de la constante que usaste para declararlo: TAM_CODIGO.

Deduzco que la función que te ha dado el profesor es la de la librería estándar rand().

Deduzco, partiendo de lo que has ido mostrando, es que el código se realiza a partir de una combinación de las letras R, Z, V, A, M, B.

Así que empiezo a escribir:

void codigoAleatorio(tCodigo codigo, bool admiteRepetidos) {
    unsigned i; // mi índice para el array.
    unsigned j; // mi índice para un array auxiliar, ver mas abajo.
    char c; // tendrá el elemento del código seleccionado.
    char elementosCodigo[] = {'R', 'Z', 'V', 'A', 'M', 'B'}; // el array que contiene los elementos que conforman el código.
    const unsigned TAM_ELEM_COD = 6; // 6 es el tamaño del array elementosCodigo. En verdad se debería sustituir 6 por 'sizeof(elementosCodigo) / sizeof(char)', pero por razones de que todavía no habrás avanzado lo suficiente en el curso lo dejo con el 6.
 
    // Ahora voy a rellenar el array codigo que ha recibido la función.
    for(i = 0; i < TAM_CODIGO; ++i) {
        j = rand() % TAM_ELEM_COD;
        // Ahora viene la parte donde trabajamos con si se admiten elementos repetidos o no.
        if(!admiteRepetidos) { // Si no se admiten repetidos...
            // La idea es cambiar el dato de elementosCodigo que ya se ha usado a 0, así sabremos que ese ya se ha pillado.
            while((c = elementosCodigo[j]) == 0) { // Mientras encontremos que el elemento seleccionado ya ha sido escogido con anterioridad
                ++j; // Elegiremos el siguiente elemento.
                if(j >= TAM_ELEM_COD); // Si el índice j queda fuera del array de código...
                    j = 0; // Se regresa el índice al inicio.
            } // Terminado el while c tendrá un carácter válido y j estará sobre ese elemento que no se ha repetido.
            elementosCodigo[j] = 0; // Para evitar que en posteriores búsquedas, para rellenar el array codigo, se elija de nuevo esta posición, se marca con el 0.
        } // Como en el paso anterior ya tenemos un elemento del código válido podemos continuar. Nótese que si se admitieran repetidos la función es la misma, lo único que todo lo que hay dentro del if se puede omitir, por eso que se ha escrito de esta forma.
        codigo[i] = c; // Se copia a la posición i del array codigo el carácter obtenido de elementosCodigo.
    } // Terminado el for ya tenemos el código listo por tanto...
} // fin de la función.

               

Vale, creo que ya lo entiendo, muchas gracias por tu ayuda.  :)

Un placer  ;-)

Si dice que tiene que devolver o retornar un código puede hacerlo con un puntero genérico (void *) y otra alternativa es modificar el array que le pasas como parámetro (por referencia) para luego modificarlo.

Ejemplo :

#include <stdio.h> 
#include <stdlib.h> 
 
/* prototipos */
void * funcionConPunteroGenerico();
void subrutina(char * cadena); 
 
void main() 
{   
    /* Aqui reservamos espacio de memoria a 'cadena' pero NO asignamos valores*/
    char * cadena=(char *) malloc(10 * sizeof(char));
 
    /* Devolvemos una cadena */
    printf(funcionConPunteroGenerico());
 
    /* Asignamos valores a la 'cadena' */
    subrutina(cadena); 
    /* Mostramos el contenido de la 'cadena' */
    printf(cadena);
 
} 
 
void * funcionConPunteroGenerico(){
    char * cadena =(char *) malloc(10*sizeof(char));
    *cadena='H';
    *(cadena+1)='o';
    *(cadena+2)='l';
    *(cadena+3)='a';
    *(cadena+4)=' ';
    *(cadena+5)='M';
    *(cadena+6)='u';
    *(cadena+7)='n';
    *(cadena+8)='d';
    *(cadena+9)='o';
    *(cadena+10)=0; /* final de la cadena */
 
    return cadena; /* Podemos devolver cualquier tipo */
}
 
void subrutina(char * cadena){ /* por referencia */
    *cadena='A';
    *(cadena+1)='d';
    *(cadena+2)='i';
    *(cadena+3)='o';
    *(cadena+4)='s';
    *(cadena+5)=0; /* final de la cadena */    
}

Esto está mal.
Dentro de funcionConPunteroGenerico capturas memoria de forma dinámica y siempre que se haga algo así se debe liberar manualmente.
Tú haces que el valor devuelto por la función sea usado por printf, pero al no capturarlo con una variable ese puntero se va a perder y quedarás con esa porción de memoria inutilizada al no poder liberarla.

Lo mismo con la variable cadena. La capturas pero nunca la liberas. Es cierto que los modernos S.O. liberan la memoria ocupada por un programa cuando éste termina pero ten en cuenta de que si alguna vez vas a trabajar con uno antiguo, un embebido o con un sistema diferente; o vayas a realizar un programa que su ejecución se alarga en el tiempo, este tipo de fallos pueden llegar a hacer lento e inestable todo el sistema.

Bueno, pienso que "Esto está mal" no es lo correcto. Déjalo en "incompleto" porque es así como indicas, faltaría la parte que libera el espacio reservado... es lo que tiene cuando trabajas con punteros.

De todas formas el código simplemente muestra las alternativas que cité en el mensaje. Gracias MAFUS, tú comentario es bastante didáctico, esperemos que no vaya a petar mi PC de 64kb  ;-) ;-)

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h>
 
void * funcionConPunteroGenerico();
void subrutina(char * cadena); 
 
void main() 
{   
    /* Aqui reservamos espacio de memoria a 'cadena' pero NO asignamos valores*/
    char cadena[10];
    char * otraCadena=funcionConPunteroGenerico();
 
    /* Devolvemos una cadena */
    printf("%s\n",otraCadena);
 
    /* Asignamos valores a la 'cadena' */
    subrutina(cadena); 
    /* Mostramos el contenido de la 'cadena' */
    printf(cadena);
 
    /* liberamos el espacio reservado del puntero */
    free(otraCadena);    
 
    /* el array no es necesario ya que apunta a la pila(memoria estática) del programa 
       , y esta es liberada al cerrar o salir del programa. */
} 
 
void * funcionConPunteroGenerico(){
    char * cadena =(char *) malloc(11*sizeof(char));
    strcpy(cadena,"Hola Mundo\0");
 
    return cadena; /* Podemos devolver cualquier tipo */
}
 
void subrutina(char * cadena){ /* por referencia */
    strcpy(cadena,"Adios\0");
}

hola de nuevo, al fin tuve clase con mi profesor y me dijo que lo que debia hacer era poner

void codigoAleatorio(tCodigo & codigo, bool admiteRepetidos);

y asi hace referencia al array que yo quiero y no me genera uno nuevo cada vez.

Pues es igual al ejemplo que te pasé, con subrutina, solo que yo use lenguaje c y por eso puse asterisco. Paso por referencia, trabaja mas rapido que paso por valor ya que no copia el objeto o valor sino trabaja directamente con el espacio donde se alojan los datos.