elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


  Mostrar Temas
Páginas: [1] 2 3
1  Programación / Scripting / No consigo abrir módulos en python en: 3 Febrero 2018, 22:02 pm
Hola
Mi problema es que instalo módulos desde la CMD con el comando "pip install numpy" , pero cuando trato de usarlos en un programa el compilador me da error en la linea en la que lo importo. Tengo windows 10 64bits y para programar en python uso Pycharm.
Si alguien sabe que puede causarlo me seria de gran ayuda.
2  Programación / Programación C/C++ / Error de definición múltiple en: 20 Enero 2018, 22:31 pm
Hola!
Cada vez que hago una clase en CodeBlocks y trato de incluirla en el archivo header de otra clase, el compilador me da un error de declaración múltiple en todos los métodos y no se a que se puede deber ya que estos solo son definidos una vez y todos los headers tienen al principio el #ifndef
Mi programa:

TicTacToeEngine.h
Código
  1. #ifndef TICTACTOEENGINE_H
  2. #define TICTACTOEENGINE_H
  3.  
  4. #include <vector>
  5. using namespace std;
  6.  
  7. class TicTacToeEngine
  8. {
  9. protected:
  10.    vector <unsigned short> board;
  11.    unsigned short state;
  12.    bool first__player_turn;
  13.  
  14.    void Check();
  15.  
  16. public:
  17.    TicTacToeEngine(void);
  18.    TicTacToeEngine( const vector<unsigned short>);
  19.    TicTacToeEngine( const TicTacToeEngine&);
  20.    ~TicTacToeEngine(void);
  21.    TicTacToeEngine operator=( const TicTacToeEngine&);
  22.  
  23.    bool Movement(unsigned short);
  24.    vector<unsigned short> Board(void) const;
  25.    void Restart(void);
  26.    unsigned short State(void) const;
  27.    bool FirstPlayer(void) const;
  28.  
  29. };
  30.  
  31. #endif // TICTACTOEENGINE_H
  32.  

TicTacToeEngine.cpp
Código
  1. #include "TicTacToeEngine.h"
  2.  
  3. //////////////////////////////////////////////////////////////////////////////////////////
  4.  
  5. // win checker
  6.  
  7. //checks if there is a line
  8. void TicTacToeEngine::Check(void)
  9. {
  10.    /////////////
  11.    //CHECK TIE//
  12.    /////////////
  13.  
  14.    unsigned short i = 0;
  15.  
  16.    while(i < 9 && board[i] != 0) {
  17.  
  18.        if(i == 8) {
  19.            state = 3;
  20.            return;
  21.        }
  22.        i++;
  23.    }
  24.  
  25.    //////////////////////
  26.    //CHECK FIRST PLAYER//
  27.    //////////////////////
  28.  
  29.    //CHECK HORIZONTAL
  30.  
  31.    //first line
  32.    if(board[0] == 1 && board[1] == 1 && board[2] == 1)
  33.        state = 1;
  34.        return;
  35.  
  36.    //second line
  37.    if(board[3] == 1 && board[4] == 1 && board[5] == 1)
  38.        state = 1;
  39.        return;
  40.  
  41.    //third line
  42.    if(board[6] == 1 && board[7] == 1 && board[8] == 1)
  43.        state = 1;
  44.        return;
  45.  
  46.    //CHECK VERTICAL
  47.  
  48.    //first line
  49.    if(board[0] == 1 && board[3] == 1 && board[6] == 1)
  50.        state = 1;
  51.        return;
  52.  
  53.    //second line
  54.    if(board[1] == 1 && board[4] == 1 && board[7] == 1)
  55.        state = 1;
  56.        return;
  57.  
  58.    //third line
  59.    if(board[2] == 1 && board[5] == 1 && board[8] == 1)
  60.        state = 1;
  61.        return;
  62.  
  63.    //DIAGONAL LINES
  64.  
  65.    //top right to bottom left
  66.    if(board[2] == 1 && board[4] == 1 && board[6] == 1 )
  67.        state = 1;
  68.        return;
  69.  
  70.    //top left to bottom right
  71.    if(board[0] == 1 && board[4] == 1 && board[8] == 1 )
  72.        state = 1;
  73.        return;
  74.  
  75.    ///////////////////////
  76.    //CHECK second PLAYER//
  77.    ///////////////////////
  78.  
  79.    //CHECK HORIZONTAL
  80.  
  81.    //first line
  82.    if(board[0] == 2 && board[1] == 2 && board[2] == 2 )
  83.        state = 2;
  84.        return;
  85.  
  86.    //second line
  87.    if(board[3] == 2 && board[4] == 2 && board[5] == 2 )
  88.        state = 2;
  89.        return;
  90.  
  91.    //third line
  92.    if(board[6] == 2 && board[7] == 2 && board[8] == 2 )
  93.        state = 2;
  94.        return;
  95.  
  96.    //CHECK VERTICAL
  97.  
  98.    //first line
  99.    if(board[0] == 2 && board[3] == 2 && board[6] == 2 )
  100.        state = 2;
  101.        return;
  102.  
  103.    //second line
  104.    if(board[1] == 2 && board[4] == 2 && board[7] == 2 )
  105.        state = 2;
  106.        return;
  107.  
  108.    //third line
  109.    if(board[2] == 2 && board[5] == 2 && board[8] == 2 )
  110.        state = 2;
  111.        return;
  112.  
  113.    //DIAGONAL LINES
  114.  
  115.    //top right to bottom left
  116.    if(board[2] == 2 && board[4] == 2 && board[6] == 2 )
  117.        state = 2;
  118.        return;
  119.  
  120.    //top left to bottom right
  121.    if(board[0] == 2 && board[4] == 2 && board[8] == 2 )
  122.        state = 2;
  123.        return;
  124.  
  125.    return;
  126. }
  127.  
  128.  
  129. //////////////////////////////////////////////////////////////////////////////////////////
  130.  
  131. // constructors & destructor
  132.  
  133. //normal constructor
  134. TicTacToeEngine::TicTacToeEngine(void) :
  135.    state(0), first__player_turn(false)
  136. {
  137.    //creates an array filled with 0 (empty board)
  138.    for(int i = 0; i < 9; i++) {
  139.        board.push_back(0);
  140.    }
  141. }
  142.  
  143. //constructor with vector as argument
  144. TicTacToeEngine::TicTacToeEngine( const vector<unsigned short> original_board) :
  145.    board(original_board), first__player_turn(false)
  146. {
  147.    Check();
  148. }
  149.  
  150. //copy constructor
  151. TicTacToeEngine::TicTacToeEngine( const TicTacToeEngine& original) :
  152.    board( original.board), state(original.state),
  153.    first__player_turn(original.first__player_turn) {}
  154.  
  155. TicTacToeEngine::~TicTacToeEngine(void) {}
  156.  
  157.  
  158. //////////////////////////////////////////////////////////////////////////////////////////
  159.  
  160. // operator =
  161.  
  162. TicTacToeEngine TicTacToeEngine::operator=( const TicTacToeEngine& original)
  163. {
  164.    board = original.board;
  165.    state = original.state;
  166.    first__player_turn = original.first__player_turn;
  167.  
  168.    return *this;
  169. }
  170.  
  171.  
  172. //////////////////////////////////////////////////////////////////////////////////////////
  173.  
  174. // Movement method
  175.  
  176. bool TicTacToeEngine::Movement(unsigned short place)
  177. {
  178.    //if the place is not between 0 and 8 or occupied or if the game has finished returns false
  179.    if( place < 0 || place > 8 || board[place] != 0 || state != 0)
  180.        return false;
  181.  
  182.    //else the place in the board is filled
  183.    if(first__player_turn) {
  184.        board[place] = 1;
  185.    }
  186.  
  187.    else {
  188.        board[place] = 2;
  189.    }
  190.  
  191.    //check if the game has ended
  192.    Check();
  193.    first__player_turn = !first__player_turn;
  194.  
  195.    return true;
  196. }
  197.  
  198.  
  199. //////////////////////////////////////////////////////////////////////////////////////////
  200.  
  201. // Return board method
  202.  
  203. vector<unsigned short> TicTacToeEngine::Board(void) const
  204. {
  205.    return board;
  206. }
  207.  
  208.  
  209. //////////////////////////////////////////////////////////////////////////////////////////
  210.  
  211. // Restart method
  212.  
  213. void TicTacToeEngine::Restart(void)
  214. {
  215.    //restarts the board array with all elements at 0
  216.    board.clear();
  217.  
  218.    for(int i = 0; i < 9; i++) {
  219.        board.push_back(0);
  220.    }
  221.  
  222.    //restarts game data
  223.    state = 0;
  224.    first__player_turn = true;
  225. }
  226.  
  227.  
  228. //////////////////////////////////////////////////////////////////////////////////////////
  229.  
  230. // Returns true if the game has finished
  231.  
  232. unsigned short TicTacToeEngine::State(void) const
  233. {
  234.    return state;
  235. }
  236.  
  237.  
  238. //////////////////////////////////////////////////////////////////////////////////////////
  239.  
  240. // Returns true if it is the turn of the first player
  241.  
  242. bool TicTacToeEngine::FirstPlayer(void) const
  243. {
  244.    return first__player_turn;
  245. }
  246.  
  247.  
  248. //////////////////////////////////////////////////////////////////////////////////////////
  249.  

TicTacToe.h
Código
  1. #ifndef TICTACTOE_H
  2. #define TICTACTOE_H
  3.  
  4. #include <iostream>
  5. #include <windows.h>
  6. #include "TicTacToeEngine.h"
  7.  
  8. using namespace std;
  9.  
  10. class TicTacToe : public TicTacToeEngine
  11. {
  12.    void Graphic(unsigned short);
  13.  
  14. public:
  15.    TicTacToe(void);
  16.    bool GraphicMovement(void);
  17.    void Play(void);
  18. };
  19.  
  20. /*
  21.  
  22. base class methods:
  23.  
  24.     TicTacToeEngine(void);
  25.     TicTacToeEngine( const vector<unsigned short>);
  26.     TicTacToeEngine( const TicTacToeEngine&);
  27.     ~TicTacToeEngine(void);
  28.     TicTacToeEngine operator=( const TicTacToeEngine&);
  29.  
  30.     bool Movement(unsigned short);
  31.     vector<unsigned short> Board(void) const;
  32.     void Restart(void);
  33.     unsigned short State(void) const;
  34.     bool FirstPlayer(void) const;
  35.  
  36. */
  37.  
  38. #endif // TICTACTOE_H

TicTacToe.cpp
Código
  1. #include "TicTacToe.h"
  2.  
  3. //////////////////////////////////////////////////////////////////////////////////////////
  4.  
  5. // constructors & destructor
  6.  
  7. //normal constructor
  8. TicTacToeEngine::TicTacToeEngine(void) :
  9.    state(0), first__player_turn(false)
  10. {
  11.    //creates an array filled with 0 (empty board)
  12.    for(int i = 0; i < 9; i++) {
  13.        board.push_back(0);
  14.    }
  15. }
  16.  
  17.  
  18. //////////////////////////////////////////////////////////////////////////////////////////
  19.  
  20. // Graphic Movement
  21.  
  22. void TicTacToe::Graphic(unsigned short i)
  23. {
  24.    if(board[i] == 0) {
  25.        cout << " ";
  26.    }
  27.  
  28.    if(board[i] == 1) {
  29.        cout << "x";
  30.    }
  31.  
  32.    if(board[i] == 2) {
  33.        cout << "O";
  34.    }
  35. }
  36.  
  37. bool TicTacToe::GraphicMovement(void)
  38. {
  39.    system("CLS");
  40.  
  41.    cout << endl << endl;
  42.    cout << "   "; Graphic(0); cout << " | "; Graphic(1); cout << " | "; Graphic(2); cout << endl;
  43.    cout << "  ------------" << endl;
  44.    cout << "   "; Graphic(3); cout << " | "; Graphic(4); cout << " | "; Graphic(5); cout << endl;
  45.    cout << "  ------------" << endl;
  46.    cout << "   "; Graphic(6); cout << " | "; Graphic(7); cout << " | "; Graphic(8); cout << endl;
  47.    cout << endl << endl;
  48.  
  49.    cout << "Movimiento del jugador";
  50.  
  51.    if(first__player_turn)
  52.        cout << " 1: ";
  53.  
  54.    if(!first__player_turn)
  55.        cout << " 2: ";
  56.  
  57.    unsigned short movement;
  58.    bool moved;
  59.    cin >> movement;
  60.  
  61.    moved = Movement(movement);
  62.  
  63.    return moved;
  64. }
  65.  
  66.  
  67. //////////////////////////////////////////////////////////////////////////////////////////
  68.  
  69. //Just play
  70.  
  71. void TicTacToe::Play(void)
  72. {
  73.    while(state == 0) {
  74.        GraphicMovement();
  75.    }
  76.  
  77.    cout << endl << endl << "End of the game." << endl << endl << "Result: ";
  78.  
  79.    if(state == 1) {
  80.        cout << "First player has won." << endl << endl;
  81.    }
  82.  
  83.    if(state == 2) {
  84.        cout << "Second player has won." << endl << endl;
  85.    }
  86.  
  87.    if(state == 3) {
  88.        cout << "Tie" << endl << endl;
  89.    }
  90. }
  91.  
  92.  
  93. //////////////////////////////////////////////////////////////////////////////////////////
  94.  
3  Programación / Programación C/C++ / Crear puntero a clase abstracta y problema usando vector en: 7 Enero 2018, 19:24 pm
Hola!
Estoy haciendo un programa que consiste en una biblioteca que puede almacenar una serie de items, que son guardados en un vector (ficha). La clase CFicha es abstracta y es la clase base para todas las demás (libros, revistas, etc...). Aquí les dejo la clase CBiblioteca:
Código
  1. class CBiblioteca
  2. {
  3.    vector<CFicha *> ficha;
  4.  
  5.    public:
  6.        //basico
  7.        CBiblioteca();
  8.        CBiblioteca(const CBiblioteca&);
  9.        ~CBiblioteca();
  10.        CBiblioteca operator=(const CBiblioteca&);
  11.        CFicha* operator[](unsigned);
  12.  
  13.        //funciones
  14.        void AnyadirFicha(CFicha&);
  15.        int BuscarFicha(const string) const;
  16.        //eliminar siguiente ?
  17.        bool EliminarFicha(unsigned);
  18.        bool MostrarFicha(unsigned);
  19.        bool MostrarBiblioteca(void);
  20. };
Mi problema se da en el método 'operator=' y 'AnyadirFicha()', los cuales son definidos así:
Código
  1. CBiblioteca CBiblioteca::operator=(const CBiblioteca& bib)
  2. {
  3.    //primero vaciamos la matriz
  4.    for(int i = 0; i < ficha.size(); i++)
  5.        delete ficha[i];
  6.  
  7.    ficha.clear();
  8.  
  9.    //ahora copiamos los elementos
  10.    for(int i = 0; i < bib.ficha.size(); i++)
  11.        ficha.push_back(new CFicha(*(bib.ficha[i])));
  12.  
  13.    return *this;
  14. }
y
Código
  1. void CBiblioteca::AnyadirFicha(CFicha& ficha)
  2. {
  3.    ficha.push_back(new CFicha(ficha));
  4. }
ambas me dan los mismos dos errores:
 'class CFicha' has no member named 'push_back'
 invalid new-expression of abstract class type 'CFicha'

pero no entiendo por que interpreta que push_back es un método de CFicha y no de la clase vector, así como mi otra duda de si se puede crear un objeto abstracto con el operador new.
4  Programación / Programación C/C++ / Array atributo de una clase de tamaño igual a otro atributo en: 31 Diciembre 2017, 17:34 pm
Hola! Necesito hacer un array de una clase y que el tamaño de este se lo de otro atributo de la misma clase, algo así:
Código
  1. private:
  2.    int tamanyo;
  3.    float array [tamanyo];
y hacerle a la clase un constructor asi:
Código
  1. Clase::Clase(int _tamanyo) : tamanyo (_tamanyo)
pero el compilador me da error... Alguien puede indicarme la forma correcta de hacerlo?
5  Programación / Programación C/C++ / Error al retornar un vector desde una funcion en: 27 Diciembre 2017, 22:43 pm
Hola

He escrito la siguiente funcion que se supone que debe cargar un vector de un archivo y retornarlo
Código
  1. vector<long int> Cargar (void)//carga el vector del archivo y lo devuelve
  2. {
  3.    ComprobarArchivo();
  4.    vector<long int> cargar;
  5.    ifstream leer; leer.open("Numeros.dat", ios::in |ios::binary);
  6.    leer.read((char *) &cargar, sizeof cargar);
  7.    return cargar;
  8. }
pero cuando la llamo desde la siguiente linea de codigo
Código
  1. vector<long int> numero = Cargar;
CodeBlocks de da el siguiente error: "conversion from 'std::vector<long int>()' to non-scalar type 'std::vector<long int>' requested" y no se por que puede estar causado...
6  Programación / Programación C/C++ / Guardar un array en un archivo en: 26 Diciembre 2017, 13:52 pm
Tengo un problema al tratar de guardar un array en un archivo con la biblioteca fstream, y es que tengo una estructura dinámica que almacena una serie de números y me interesa guardarla de alguna forma, por lo que he decidido meter todos los valores en una estructura con un array (el cual es de tamaño variable, puesto que la cantidad de números que tiene que almacenar varía) y almacenar esta estructura en el fichero.
La estructura es la siguiente:
Código
  1. long int cantidadAlmacenar = 0;
  2. struct guardarArchivo{
  3.    long int cantidad = cantidadAlmacenar;
  4.    long int numero [cantidad] = {0};
  5. };

Y la funcion que transforma la estructura dinámica en el array (en verdad es un método de una clase)es la siguiente:
Código
  1. void CCifras::guardarArchivo(void)
  2. {
  3.    struct guardarArchivo guardar;
  4.    struct nodo* guia = comienzo;
  5.    for(int i = 0; i < cantidad; i++)
  6.    {
  7.        guardar.numero[i] = guia.numero;
  8.        guia = guia.siguiente;
  9.    }
  10.    ofstream ficheroEscribir; ficheroEscribir.open ("BaseDatos.dat", ios::out | ios::binary);
  11.    ficheroEscribir.write((char *) &guardar, sizeof(guardar));
  12.    ficheroEscribir.close();
  13. }
Pero esta técnica hace aguas por todas partes (ya la he utilizado y funciona cuando la cantidad de valores a almacenar es fija, pero este no es el caso) y el compilador me da el error: "invalid use of non-static data member" en la linea donde pone
Código
  1. long int numero [cantidad] = {0};
.
El caso, si alguien puede decirme cual es el fallo en mi forma de hacerlo o directamente la forma correcta de hacer lo que quiero se lo agradecería XD
7  Programación / Programación C/C++ / Método para convertir double a objeto en: 20 Diciembre 2017, 21:53 pm
Hola, tengo una clase que trabaja con polinomios (CPolinomio) y me gustaría hacer un método que fuese capaz de convertir un double d en un objeto ( sería el polinomio d*x^0) pero solo se hacer conversiones de objeto a otro tipo de valor (si mal no recuerdo)
Clase::operator tipo_valor(); pero no se como hacer lo contrario. Sospecho que debe ser algo así como una función externa amiga de la clase, pero no se como proceder más allá de eso...
8  Programación / Programación C/C++ / Problema al sobrecargar el operador + en: 18 Diciembre 2017, 20:07 pm
Ya se por que sucede el error que se muestra en este post, pero ahora el problema es otro (se dice en mi respuesta al mismo) no hace falta leer el código del programa para saber cual es mi duda. Por favor leed mi respuesta en el hilo para poder ayudarme, gracias.

Hola, he creado el siguiente programa para manejar y operar polinomios, consta de una clase llamada termino (c*x^e) y una clase llamada polinomio que es básicamente un array de términos y sus correspondientes operaciones, así como un método para mostrar el polinomio por pantalla. El codigo es algo largo pero el problema está principalmente en el método operator+, el cual si pido que muestre por pantalla el resultado (antes del return) el polinomio es correcto, pero una vez que lo devuelve y lo asigna a otro objeto polinomio y hago que este ultimo se muestre por pantalla es incorrecto (espero haberme hecho entender). Aquí os dejo el codigo:

main.cpp
Código
  1. #include <iostream>
  2. #include "CPolinomio.h"
  3.  
  4. using namespace std;
  5.  
  6. int main()
  7. {
  8.    CPolinomio p1(5,7);
  9.    CPolinomio p2(3,6);
  10.    CPolinomio p3;
  11.  
  12.    p1.asignarTermino(4,5);
  13.    p1.asignarTermino(10,3);
  14.    p2.asignarTermino(4,3);
  15.    p2.asignarTermino(5,5);
  16.    p2.mostrarPolinomio(); cout << " + ";
  17.    p1.mostrarPolinomio(); cout << endl;
  18.    p3 = p1 + p2; cout << endl;
  19.    (p1 + p2).mostrarPolinomio(); cout << endl;
  20.    p2.mostrarPolinomio();
  21.    //p2 = p1 + p1 + p1;
  22.    //p2.mostrarPolinomio();
  23.    //(p1+p1).mostrarPolinomio();
  24.  
  25.    return 0;
  26. }
  27.  

CTermino.h
Código
  1. #ifndef CTERMINO_H
  2. #define CTERMINO_H
  3.  
  4.  
  5. class CTermino
  6. //Cada uno de los terminos del polinomio
  7. {
  8. private:
  9.    double coeficiente;
  10.    int exponente;
  11. public:
  12.    CTermino(double = 0, int = 0);
  13.    void asignarCoeficiente (double);
  14.    void asignarExponente (int);
  15.    double obtenerCoeficiente (void) const;
  16.    int obtenerExponente (void) const;
  17.    void mostrar(void) const;
  18. };
  19.  
  20. #endif // CTERMINO_H
  21.  

CTermino.cpp
Código
  1. #include "CTermino.h"
  2. #include <iostream>
  3.  
  4. CTermino::CTermino(double c, int e) :
  5. coeficiente(c), exponente(e)
  6. {
  7.    if(e < 0){exponente = -e;}
  8. }
  9.  
  10. void CTermino::asignarCoeficiente (double c) {coeficiente = c;}
  11.  
  12. void CTermino::asignarExponente (int e)
  13. {
  14.    if(e < 0){exponente = -e;}
  15.    else{exponente = e;}
  16. }
  17.  
  18. double CTermino::obtenerCoeficiente (void) const {return coeficiente;}
  19.  
  20. int CTermino::obtenerExponente (void) const {return exponente;}
  21.  
  22. void CTermino::mostrar(void) const//es muy enrrevesado para mostrar los terminos como se suele hacer en algebra...
  23. {
  24.    if(!(coeficiente >= 0)){std::cout << " ";}
  25.    if(coeficiente > 0) std::cout << " +";
  26.    if(coeficiente != 1 && coeficiente != -1) {std::cout << coeficiente;}
  27.    if(coeficiente == -1 && exponente == 1) std::cout << "-";
  28.    if(exponente > 0)
  29.    {
  30.        if(exponente == 1) std::cout << "x";
  31.        else std::cout << "x^" << exponente;
  32.    }
  33. }

CPolinomio.h
Código
  1. #ifndef CPOLINOMIO_H
  2. #define CPOLINOMIO_H
  3. #include "CTermino.h"
  4.  
  5.  
  6. class CPolinomio
  7. {
  8. private:
  9.    CTermino* termino;
  10.    int grado;
  11.    void crearPolinomio (int);
  12.    void ampliar (int);
  13. public:
  14.    CPolinomio(double = 0,int = 0);
  15.    ~CPolinomio();
  16.    int obtenerGrado (void) const;
  17.    void asignarTermino (double , int);
  18.    void mostrarPolinomio(void) const;
  19.    const CPolinomio operator=(const CPolinomio&);
  20.    const CPolinomio operator+(const CPolinomio&) const;
  21.    const CPolinomio operator*(const CPolinomio&) const;
  22. };
  23.  
  24. #endif // CPOLINOMIO_H
  25.  

CPolinomio.cpp
Código
  1. #include "CPolinomio.h"
  2. #include <iostream>
  3.  
  4. CPolinomio::CPolinomio(double c, int e)//Constructor que crea la matriz de terminos del tamaño necesario
  5. {
  6.    grado = e; if(e < 0) {grado = -e;}//si el exponente es negativo lo cambia
  7.    crearPolinomio(e);
  8.    termino[e].asignarCoeficiente(c);//asigna el coeficiente al exponente correcto
  9. }
  10.  
  11. void CPolinomio::crearPolinomio(int g)//crea la matriz de objetos termino del tamaño necesario
  12. {
  13.    delete [] termino; termino = new CTermino [g+1];
  14.    for (int i = 0; i <= g; i++) termino[i].asignarExponente(i);
  15. }
  16.  
  17. void CPolinomio::ampliar (int g)//amplia la matriz terminos al tamaño pasado por parametro
  18. {
  19.    double coeficientes [grado+1];
  20.    for(int i = 0; i <= grado; i++) coeficientes [i] = termino[i].obtenerCoeficiente();//copia los terminos en una matriz
  21.    crearPolinomio(g);
  22.    for (int i = 0; i <= grado; i++) termino[i].asignarCoeficiente(coeficientes [i]);//copia los terminos de vuelta al nuevo array
  23.    grado = g;
  24. }
  25.  
  26. CPolinomio::~CPolinomio()
  27. {
  28.    delete [] termino;
  29. }
  30.  
  31. int CPolinomio::obtenerGrado(void) const {return grado;}
  32.  
  33. void CPolinomio::asignarTermino(double c, int e)
  34. {
  35.    if(e < 0) return;//SI NO ES VALIDO NO HACE NADA
  36.    if(e > grado)//SI EL EXPONENTE ES MAYOR QUE EL GRADO CREA UN NUEVO POLINOMIO ADECUADO
  37.    {
  38.        ampliar(e);
  39.        termino[e].asignarCoeficiente(c);
  40.    }
  41.    else {
  42.        termino[e].asignarCoeficiente(c);//SI TODO ES NORMAL SIMPLEMENTE LO CAMBIA
  43.    }
  44. }
  45.  
  46. void CPolinomio::mostrarPolinomio(void) const//funcion que muestra el polinomio
  47. {
  48.    std::cout << "(";
  49.    for(int i = grado; i > 0; i--) {if(termino[i].obtenerCoeficiente() != 0)termino[i].mostrar();}
  50.    if(termino[0].obtenerCoeficiente() != 0) termino[0].mostrar();
  51.    std::cout << ")";
  52. }
  53.  
  54. const CPolinomio CPolinomio::operator=(const CPolinomio& pol)//operador =
  55. {
  56.    grado = pol.grado;
  57.    ampliar(pol.grado);
  58.    for(int i = 0; i <= pol.grado; i++) termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente());
  59. }
  60.  
  61. const CPolinomio CPolinomio::operator+(const CPolinomio& pol) const//operador +
  62. {
  63.  
  64.    if(grado == pol.grado)//si ambos grados son iguales (no hay que ampliar)
  65.    {
  66.        CPolinomio resultado(0, grado);
  67.        for(int i = 0; i <= resultado.grado; i++)
  68.        {
  69.            resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente() + termino[i].obtenerCoeficiente());
  70.        }
  71.        resultado.mostrarPolinomio();//codigo experimental para saber si el error es al devolver el objeto
  72.        return resultado;
  73.    }
  74.    else {
  75.        if(grado > pol.grado)//si uno de los polinomios tiene mas grado
  76.        {
  77.            CPolinomio resultado(0, grado);
  78.            for(int i = 0; i <= pol.grado; i++)
  79.            {
  80.                resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente() + termino[i].obtenerCoeficiente());
  81.            }
  82.            for(int i = pol.grado+1; i <= grado; i++) resultado.termino[i].asignarCoeficiente(termino[i].obtenerCoeficiente());
  83.            resultado.mostrarPolinomio();//codigo experimental para saber si el error es al devolver el objeto
  84.            return resultado;
  85.        }
  86.        if(grado < pol.grado)//si el otro polinomio es mayor
  87.        {
  88.            CPolinomio resultado(0, pol.grado);
  89.            for(int i = 0; i <= grado; i++)
  90.            {
  91.                resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente() + termino[i].obtenerCoeficiente());
  92.            }
  93.            for(int i = grado+1; i <= pol.grado; i++) resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente());
  94.            resultado.mostrarPolinomio();//codigo experimental para saber si el error es al devolver el objeto
  95.            return resultado;
  96.        }
  97.    }
  98. }
  99.  
  100. const CPolinomio CPolinomio::operator*(const CPolinomio& pol) const//operador *
  101. {
  102.    int gr = pol.grado*grado;
  103.    CPolinomio resultado(gr);
  104.  
  105.    for (int i = 0; i <= grado; i++)
  106.    {
  107.        if(termino[i].obtenerExponente() != 0)
  108.        {
  109.            CPolinomio calculos;
  110.            for(int x = 0; x <= pol.grado; x++)
  111.            {
  112.                calculos.asignarTermino(termino[i].obtenerCoeficiente() * pol.termino[x].obtenerCoeficiente(), termino[i].obtenerExponente() + pol.termino[x].obtenerExponente());
  113.            }
  114.            resultado = resultado + calculos;
  115.        }
  116.    }
  117.  
  118.    return resultado;
  119. }

Cuando lo ejecuto se muestra lo siguiente:

( +3x^6 +5x^5 +4x^3) + ( +5x^7 +4x^5 +10x^3)
( +5x^7 +3x^6 +9x^5 +14x^3)
( +5x^7 +3x^6 +9x^5 +14x^3)( +5x^1981370576 +9.88131e-324)
( +3x^6 +5x^5 +4x^3)
Process returned 0 (0x0)   execution time : 0.111 s
Press any key to continue.


Espero que alguien sepa que puede ser, sospecho que estoy retornando el objeto resultado de operator+ mal...
9  Programación / Programación C/C++ / error: 1d returned exit status en: 17 Diciembre 2017, 12:20 pm
Codeblocks me ha mostrado el mensaje de error "error: 1d returned exit status" cuando traté de compilar mi proyecto (sin indicar ninguna línea del código ni nada) y no se que hacer... si alguien sabe a que se puede deber apreciaría la ayuda, gracias.

Pd: no pongo el código del programa por que en algún foro que he ojeado indicaban que el error no se debía al código en si, pero si alguien quiere verlo puedo subirlo como respuesta.
10  Programación / Programación C/C++ / Donde incluir librerías en clases en: 15 Diciembre 2017, 16:33 pm
Hola, he hecho un pequeño programa para acompañar mi pregunta

main.cpp
Código
  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7.    clase miClase(42);
  8.    miClase.mostrar();
  9.    return 0;
  10. }
  11.  

clase.h
Código
  1. #ifndef CLASE_H
  2. #define CLASE_H
  3. #include <iostream>
  4.  
  5. class clase
  6. {
  7. private:
  8.    int numero;
  9. public:
  10.    clase (int n=0);
  11.    void mostrar(void) const;
  12. };
  13.  
  14. #endif // CLASE_H

clase.cpp
Código
  1. #include "clase.h"
  2. #include <iostream>
  3.  
  4. clase::clase (int n) : numero(n){}
  5.  
  6. void clase::mostrar(void) const
  7. {
  8.    cout << numero << endl;
  9. }
  10.  

pues bien, cuando compilo este proyecto codeblocks me dice que el "cout" de la linea 8 de clase.cpp "was not declared in this scope", y lo mismo para el endl. Supongo que he incluido iostream de forma equivocada, si alguien me puede decir como incluir las librerias de forma correcta...
Gracias   :-*
Páginas: [1] 2 3
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines