Mensajes

It es un iterador de un vector.

Ya corregí el error, estaba usando un vector y en realidad tenía que usar una lista. Estaba buscando diferencias y resulta que por estar todo el tiempo generando nuevas balas y eliminando encontré esto:

Lists are faster when you regularly need to insert elements in between two other elements, or delete elements from such positions though. Insertions and erasures are cheap no matter where in the list they occur. Iterators remain valid even when you add or remove elements from the list.

Así que simplemente cambié de un vector a una lista y funcionó. Escribo esto por si a alguien se le presenta lo mismo.

Pero gracias por responder igual.

[rng_fuera()]

Vean, estaba haciendo una especie de "juego", y a la hora de programar la rutina de las balas me ha surgido un problema, podemos disparar las veces que queramos y no pasará nada, pero en el momento cuando la última bala llega al tope, el programa deja de funcionar.

El error está (creo) en la liberación de la memoria dinámica, no sé qué estoy haciendo mal. Verán, esta es la parte:

Código (cpp) [Seleccionar] Expandir


       for(it = balas.begin(); it != balas.end(); ++it) {
           (*it)->borrar_bala((*it)->GetX(),(*it)->GetY());
           if(!(*it)->rng_fuera()) {
               (*it)->mod_pos_bala((*it)->GetY());
               (*it)->pintar_bala();
           }
           else {
               delete (*it);
               balas.erase(it);
           }
       }


La función rng_fuera() retorna un valor booleano, retorna true si la bala ha llegado al tope, es decir, cuando y = 0. Y false en caso contrario.

Entonces yo, como se muestra arriba, borro de la pantalla la posición actual de la bala, si ha llegado al tope, pues libero la memoria y borro ese elemento del vector, en caso contrario modifico la posición actual de la bala a la nueva posición y la pinto. Pero algo sucede y no puedo encontrar el error.

Si necesitan el código completo para entenderlo mejor, pídanmelo y lo publico en los comentarios.

Supongo que lo más "difícil" es dibujar el cuadrado. Pues nada, como ha dicho furciorifa, 2 búcles, uno dentro de otro (anidados), el de dentro pintará cada una de las columnas y el de afuera se desplazará por las filas.

No debería hacer esto, pero en fin, sería así:

Código (cpp) [Seleccionar] Expandir


void pintar_cuadrado(const int base, const int altura) {
    std::cout << "--- GRAFICA ---\n" << std::endl;

    for(int i = 0; i < altura; i++) {
        for(int j = 0; j < base; ++j) {
            std::cout << "X";
        }
        std::cout << std::endl;
    }
}


He presionado "citar" en lugar de editar, vaya torpe. xD

[cargar_vector]

y excluir el numero negativo que se ingresó al final para terminar de ingresarlo

Eso me ha confundido. XD

Según lo que entendí lo que puedes hacer es pedir los valores, si es menor que 0 cortas el búcle, y es imposible que ingreses más de 10 valores ya que el búcle te lo prohíbe, una vez llegues ahí se cortará. Y si quieres saber cuántos elementos hay en el arreglo entonces la función cargar_vector hazla entera y retorna el valor de longitud, no tiene mucho sentido que lo pases como parámetro e inmediatamente lo pongas igual a cero. Es decir, quedaría algo así:

Código (cpp) [Seleccionar] Expandir


int cargar_vector(int vector[])
{
int longitud=1; //El 1 es porque ya contarás al primer elemento
   cout<<"Ingrese los numeros del vector: ";

while(longitud<(MAX + 1)) /* el + 1 es porque estamos contando desde 1, si no estaríamos cogiendo solo 9 valores.*/
{
 cin>>vector[longitud];

 if(vector[longitud]<0)
 {
 break;
 }

 longitud++;

}

return longitud;
}


Y el main quedaría así:

Código (cpp) [Seleccionar] Expandir


int main()
{

int vector[MAX];

imprimir_vector(vector, cargar_vector(vector));

return 0;
}



Y imprimir_vector te quedaría así:

Código (cpp) [Seleccionar] Expandir


void imprimir_vector(int vector[], int longitud) {
    for(int i = 0; i < longitud; ++i) {
         if(vector[i] < 0) {
              vector[i] = 0; // Encontramos un valor negativo y lo sustituimos por 0.
              break;
         }
         cout << vector[i];
    }
}


Edit: Una cosa que me he dado cuenta a último momento, en la función main el arreglo está cogiendo 11 valores, no 10, tendrías que hacer MAX igual a 9. Pero entonces quitarías el + 1 que he puesto en el búcle.

No me quedó del todo claro lo que intentas hacer, pero acá varias cosillas:

Código (cpp) [Seleccionar] Expandir


cout << "DADES:" << endl;
    cin >> numero; // <- Acá
    while (numero != EOS)
    {
        cin >> numero; // <- Estás pidiendo el mismo valor 2 veces.
        sumaXifres(numero) = n;
    }


También estás declarado numero y número1, y "numero1" nunca la utilizas, así que:

Código (cpp) [Seleccionar] Expandir


if ((sumaXifres(numero)) == (sumaXifres(numero1))) // <- Este if jamás se cumplirá.
    {
        cout << "LA SEQUENCIA CONTE UNA PARELLA CONSECUTIVA AMB IGUAL SUMA DE XIFRES:" << numero << "," << numero1;;
    }


Y no es válido hacer esto:

Código (cpp) [Seleccionar] Expandir


sumaXifres(numero) = n; /*A menos que la función retorne una referencia, y a esta se le asigna el valor de la variable 'n'*/


En fin, si lo que quieres es ir guardando valores de manera indefinida e ir registrando al mismo tiempo la suma de sus números que componen a ese entero puedes usar vectores.

Código (cpp) [Seleccionar] Expandir


int main() {
   
    int valor;
    vector<int> enteros, sumas;
   
    cin >> valor;
   
    while(valor != EOS) {
        enteros.push_back(valor);
        sumas.push_back(sumaXifres(valor));
        cin >> valor;
    }
   
    return EXIT_SUCCESS;
}


Y luego recorrerás cada valor del vector hasta encontrar otro valor que coincida con la suma. Y lógicamente el valor de la suma tendrá el mismo índice que el del número entero en sí. Por lo que vas comparando el primer valor con el resto, y así sucesivamente con todos hasta dar con otro igual y luego muestras los 2.

Oh, ya lo he pillado. No debí precipitarme en publicar esto, mi error. Un moderador por favor cierre el tema.

Bueno, iré al grano, me puse a crear una librería dinámica y para ser honesto no sé si estoy haciendo bien la importación/exportación.

Acá el código:

// main.h

Código (cpp) [Seleccionar] Expandir


#ifndef __MAIN_H__
#define __MAIN_H__


#ifndef DLL_MATH
   #define DLL_MATH __declspec(dllimport)
#else
   #define DLL_MATH __declspec(dllexport)
#endif

int DLL_MATH suma(int a, int b);
int DLL_MATH resta(int a, int b);
int DLL_MATH multip(int a, int b);

#endif //__MAIN_H__



// main.cpp

Código (cpp) [Seleccionar] Expandir


#include "main.h"

int DLL_MATH suma(int a, int b) {
   return (a + b);
}

int DLL_MATH resta(int a, int b) {
   return (a - b);
}

int DLL_MATH multip(int a, int b) {
   return (a*b);
}



Como verán es bastante simple, hasta ridículo. Si cambio el orden, es decir, de esta forma:

//main.h

Código (cpp) [Seleccionar] Expandir


#ifndef __MAIN_H__
#define __MAIN_H__


#ifndef DLL_MATH
   #define DLL_MATH __declspec(dllexport)
#else
   #define DLL_MATH __declspec(dllimport)
#endif

int DLL_MATH suma(int a, int b);
int DLL_MATH resta(int a, int b);
int DLL_MATH multip(int a, int b);

#endif //__MAIN_H__



Sí funciona, pero a lo mejor he captado mal de dónde he leído, ¿no se suponía que si la macro no estaba definida se debía importar en la DLL, y una vez definida, exportar hacia el programa con el cual la estemos corriendo? Corregidme acá, por favor.

Como dice ivancea96, plantea el algoritmo en un papel y así te resultará todo más claro cuando lo pases a código ya que sabrá lo que tienes que hacer y no lo harás todo a "pegar" a ver si funciona.

Para invertir un número lo que tienes que hacer es tomar la última cifra, luego tienes que ir desplazándola para sumarle la siguiente, por lo que tienes que multiplicar por 10 y sumarle la siguiente, y así hasta que el valor del número a invertir sea cero.

Teniendo eso en mente, el código quedaría algo así:

Código (cpp) [Seleccionar] Expandir


#include <iostream>

int invertir(int n) {
    int nInvertido = 0;

    while(n != 0) {
        nInvertido = (nInvertido * 10) + (n % 10);
        n /= 10;
    }

    return nInvertido;
}

int main() {
    int numero;
    std::cout << "Introduzca numero: "; std::cin >> numero;
    std::cout << "Numero invertido: " << invertir(numero);
    std::cin.get();
    return 0;
}



Simplemente cojes el valor inicial y lo vas aumentando hasta llegar al valor final y eso es todo. Un búcle for podría servirte para ello.

Código (cpp) [Seleccionar] Expandir


#include <iostream>
using namespace std;

int main() {
    int inicio, fin;

    cout << "Numero inicial: "; cin >> inicio;
    cout << "Numero final: "; cin >> fin;

    for(int h = inicio; h <= fin; ++h) {
        cout << h << endl;
    }

    cin.get();
    return 0;
}