Mensajes

Cuando no puedas usar variables globales o aunque puedas si prefieres no usarlas ya que no es recomendable porque el código pierde seguridad, todo lo que no puedes usar en una función porque no es global, se lo pasas como parámetros. Además los vectores cuando no se usa todavía memoria dinámica se suelen crear usando una constante para el tamaño, así si luego se quiere cambiar el tamaño, basta con cambiar el valor de esa constante.

Te pongo un ejemplo bastante completo que tiene cómo pasar arrays como parámetros, cómo usar constantes y qué hacer si no vamos a usar el array entero.

Código (c) [Seleccionar] Expandir


#include <stdio.h>

const int TAM = 100;

void mostrarVector(int[], int);

int main(){
    int vector[TAM];
    int util = 10; // se podria preguntar al usuario cuantos valores quiere ingresar
    for(int i = 0; i < util; i++){
        printf("Elemento %d: ", i);
        scanf("%d", &vector[i]);
    }
    printf("\nEl contenido del array es: ");
    mostrarVector(vector, util);
}

void mostrarVector(int v[], int size){
    for(int i = 0; i < size; i++)
        printf("%d  ", v[i]);
    printf("\n");
}

Ahora aprovecha las cosas que aparecen en este ejemplo para adaptarlo a tu código. Suerte

PD: No utilices la librería <conio.h>, no es estándar.

Mafus gracias,se nota que sabes programar avanzado pero es demasiado eso para mi, ajaajaj, hace de cuenta que le estas enseñando a un cavernicola, porque  usas sizeof?, y que significa --s?

Aunque ya tengas el tema solucionado, lo importante es resolver las dudas que quedan así que...
- <sizeof()> se usa para obtener el número de bytes que ocupa un tipo de dato. En ese código te devuelve el número de bytes que ocupa un <unsigned long long>.
- <--s> significa decrementar <s> en 1. Al igual que se suele hacer <i++>, se puede hacer también <i-->, <++i> o <--i>. A veces da igual usar el prefijo o el sufijo (cuando es una sentencia aislada, que no va como "encadenada"). El prefijo primero hace el incremento/decremento y después el resto de la sentencia; el sufijo primero hace el resto de la sentencia y al final hace el incremento/decremento.

Código (c) [Seleccionar] Expandir


for(int i = 0; i < 5; i++) // aqui da igual i++ o ++i porque esta solo
    printf("%d", i++); // primero muestra i y luego lo incrementa en 1. Salida: 0, 2, 4

for(int i = 0; i < 5; i++)
    printf("%d", ++i); // incrementa i y luego lo muestra. Salida: 1, 3, 5 (el 5 se muestra aunque la condicion es i < 5)

tampoco entiendo porque le pasas como parametro n>>1

Si haces <num >> 1> lo que haces es mover los bits de <num> una posición a la derecha. Si tienes:
a = 01011001
a >> 1
a = 00101100
Si el número es negativo se extiende con unos:
a = 11010011
a >> 1
a = 11101001

Como dato interesante que si no te paras a estudiar los bits no te das cuenta es que mover una posición a la izquierda un número en binario es equivalente a multiplicar ese número por 2. Y entonces moverlo una posición a la derecha es equivalente a dividirlo por 2, aunque si es impar se hará obviando los decimales.



Entonces para que entiendas el código ese que la verdad aunque poco efectivo, me parece impresionante:
Usa una función donde manda un <unsigned long long> que es el número a calcular y le pasa como segundo parámetro el número de bits que ocupa un número <unsigned long long> (con <sizeof()> saca el número de bytes y eso por 8, en bits).
Entonces cuando <s == 1> es decir, cuando sólo quede el bit más significativo se retorna ese bit (que valdrá 1 si el número es negativo o 0 si no lo es). Y si <s != 1>, mueve todos los bits una posición a la derecha y decrementa el número de bits que quedan todavía. Algo así en un caso simplificado:
n = 4 (0100) s = 4
s == 1? No -> n = 2 (0010) s = 3
s == 1? No -> n = 1 (0001) s = 2
s == 1? No -> n = 0 (0000) s = 1
s == 1? Si -> return n (return 0)

n = -2 (1110) s = 4
s == 1? No -> n = -1 (1111) s = 3 // los negativos se extienden con 1 para que sigan siendo negativos (cosas del complemento a 2)
s == 1? No -> n = -1 (1111) s = 2
s == 1? No -> n = -1 (1111) s = 1
s == 1? Si -> return n (return 1)



Una función de ese estilo es mejor que no muestre nada por pantalla por si quieres usar esa función dentro de un condicional, sería más funcional entonces sin los <printf()>:

Código (c) [Seleccionar] Expandir


int positivo(int n){
    if(n >= 0)
        return 1;
    else
        return !negativo(n);
}

int negativo(int n){
    if(n < 0)
        return 1;
    else
        return !positivo(n);
}

Espero que esto te ayude a entender y profundizar más en todo lo que se puede hacer con la programación. Suerte

No entiendo muy bien tu duda, pero si quieres pasar un array n-dimensional a una o más funciones claro que puedes hacerlo. Simplemente tienes que pasar en otro/s parámetro/s su tamaño para poder recorrerlo.
Si no he resuelto tu duda y me puedes explicar un poco mejor a que te refieres, intentaré ayudarte. Suerte 

Si pudieras especificar un poco más tu problema... Es decir, ese programa compilar, compila (si le añades la librería <stdio.h> para poder usar <scanf()> y <printf()>). Además puedes quitar <stdlib.h> y <string.h> ya que no estás usándolo para nada en todo el programa.

De todos modos ese programa sigue teniendo errores (aunque ya compila). Si llamas a <positivo(n)> con n positivo, sale el mensaje por pantalla "el numero ingresado es positivo" pero no has hecho ningún <return> (creo que entonces se retorna n pero es mejor especificarlo en el código para que quede explícito).

Si llamas a <negativo(n)> con n negativo, la función retorna n, pero no se mostrará por pantalla "el numero ingresado es nevativo" (creo que querías poner "neGativo" ) porque una vez que una función ejecuta un <return> ya sale de la función y no se ejecuta lo que venga después.

Por eso que no se muy bien cual es el fin de esa función, si quieres retornar el mismo número que mandas como parámetro o quieres retornar 1 o 0 como si fuese true o false respectivamente... Y sí, si quieres crear otra función que llame a una de esas puedes hacerlo, pero lo veo un poco absurdo todo esto porque son dos funciones muy sencillas. Algo más funcional sería:

Código (c) [Seleccionar] Expandir


int positivo(int n){
   return (n >= 0);
}
Que devuelve 1 si es positivo y 0 si es negativo. De que sirve crear una función <negativo()> si <negativo() == !positivo()>??

Los vectores de la stl no se usan así. Mírate en cualquier sitio cómo funciona un vector y cómo funciona la función <fgets()>. Tienes que crear una variable auxiliar y después meterla en el vector, a grandes rasgos...

PD: Creo que estás interpretando mal el ejercicio, un array de palabras es un array de <string>, no de <char>. Has creado un vector de caracteres, no se palabras.

Aparte de eso, aunque el <for> se puede usar como lo estás usando en ese código, no es muy correcto. De todos modos el error más grave es el tipo del vector, miratelo a ver. Suerte

Alguien me puede decir si asi es el metodo correcto para llenar  una matriz?

Pon tu código entre etiquetas de código GeSHi porque la letra i entre corchetes es una etiqueta de cursiva y no se ve correctamente, sino que la etiqueta desaparece y parece que estás accediendo mal a los elementos de la matriz. Suerte

[Y este otro procedimiento cuenta la cantidad de nodos que tienen un solo hijito]

Puedo estar equivocado, pero creo que cantidad_nodos debería sumar siempre uno.

Aunque lo ha llamado <cantidad_nodos> lo que quiere es contabilizar los nodos que tienen un único hijo, por eso está implementado así

Y este  otro procedimiento cuenta la cantidad de nodos que tienen un solo hijito

Aquí tienes unos cuantos líos y cosas que no están bien entendidas...
Lo primero las clases y estructuras es mejor que las declares fuera de ninguna otra función. Es decir, antes de la función <testList()>.

Y ahora voy a intentar explicarte la idea de crear esa estructura. Si quieres hacer una lista de valores en forma polar, para no meter por un lado el módulo y por otro el ángulo, lo que se hace es un objeto que engloba ambos, es decir, en vez de tener dos variables de tipo <double> (modulo y angulo), se tiene una variable de tipo <polar> y esa variable por dentro lleva guardados tanto el módulo como el ángulo para que no guardarlos por ahí sueltos.
Entonces la lista tiene que ser de tipo <polar>, no de tipo <int> ni <double>.

Tú has creado una variable que creo que piensas que es de tipo <polar> pero no es así. Esa es una variable que es de tipo <int> o <double> según el caso y que se llama polar. Nada que ver con lo que quieres hacer. Para crear una variable de tipo polar y guardar valores dentro es así:

Código (cpp) [Seleccionar] Expandir


polar variable_polar;
variable_polar.modulo = // lo que sea;
variable_polar.angulo = // lo que sea;

Una vez que tengas esa variable de tipo <polar> con sus datos actualizados entonces es cuando ya puedes meterlo en la lista. Es decir, meter tu variable de tipo <polar> en tu lista de tipo <polar>.

Ahora vamos al <case 2:>:
Parece que quieres hacer una cola <queue> usando una lista. Si usas el método para sacar el elemento del frente, no necesita ningún parámetro, el elemento del frente sólo es uno, no hay otro. Si sacas el elemento de la cola ya no existe, entonces si quieres mostrarlo tienes que guardarlo en algún sitio. O lo que se suele hacer es mostrar primero el elemento que hay al frente de la cola y cuando ya lo has mostrado, lo sacas de esta. Estás usando continuamente la variable llamada <polar> que no pinta nada.

Y ya para terminar te recomiendo que hagas un <default> en el <switch> por si introduces un número que no sea {1,2,3} porque si es 1 o 2 haces lo que que has implementado, si es 3 acaba, pero si alguien introduce 4??

Creo que tienes un lío de conceptos y te recomiendo aclarar eso antes de seguir con programas mayores... Suerte

La variable <private_iterator> es un std::set<T>::iterator, es decir; un iterador de set. El tema de hacer que devuelva un puntero a entero es porque si no se usa la flecha la otra alternativa sería esta:

Código (cpp) [Seleccionar] Expandir


(*private_iterator).metodo();
private_iterator->metodo();

Por eso he deducido que el valor de retorno del operador -> sería un puntero al tipo de dato que retorna el *.

PD: No he probado si se soluciona con lo que me comentas de hacer el método constante. Cuando pueda lo probaré y si funciona ya lo comentaré por aquí. Es que he estado buscando bastante información en internet sobre este operador y sobre sobrecargarlo y lo único que he encontrado es que se puede sobrecargar pero no he encontrado cómo se haría. Gracias por la respuesta

Pues mira, creo que poniendo

Código (cpp) [Seleccionar] Expandir

int operator->()const

Ya he probado esto a ver si funciona y no. Tengo el mismo problema usando esa función que si uso la primera que he mostrado yo. De momento la única solución que he encontrado es que el valor de retorno sea constante. Si alguien sabe algo más al respecto...

Tengo la siguiente clase y estoy intentando sobrecargar el operador -> pero sólo puedo sobrecargarlo con constantes, me explico:

Código (cpp) [Seleccionar] Expandir


class ConjuntoEnteros{
    private:
        std::set<int> private_set;
    public:
        ConjuntoEnteros();
        // ...
        class Iterator{
            private:
                 std::set<int>::iterator private_iterator;
            public:
                  Iterator();
                  // ...
                  int* operator->(){
                      return &*private_iterator;
                  }
         };
};

Entonces si intento sobrecargar ese operador -> me da un error. Lo he conseguido solucionar modificándolo así:

Código (cpp) [Seleccionar] Expandir


const int* operator->(){
     return &*private_iterator;
}

Entonces no sé si es posible sobrecargar ese operador cómo lo había intentado al principio o siempre tiene que ser constante.