Mensajes

Vale, acabo de solucionarlo... efectivamente, el problema estaba en Pycharm. Para añadir módulos se debe de ir a settings y en las opciones del compilador aparece un menú con los módulos instalados y otra opción para añadir más.

empiezo a pensar que tal vez sea problema del Pycharm, alguien que use el programa sabe si hay que importar o incluir los módulos en el programa también?

Pyton 3.6.4

El error es "ModuleNotFoundError: No module named 'Numpy'"

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.

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 (cpp) [Seleccionar] Expandir

#ifndef TICTACTOEENGINE_H
#define TICTACTOEENGINE_H

#include <vector>
using namespace std;

class TicTacToeEngine
{
protected:
    vector <unsigned short> board;
    unsigned short state;
    bool first__player_turn;

    void Check();

public:
    TicTacToeEngine(void);
    TicTacToeEngine( const vector<unsigned short>);
    TicTacToeEngine( const TicTacToeEngine&);
    ~TicTacToeEngine(void);
    TicTacToeEngine operator=( const TicTacToeEngine&);

    bool Movement(unsigned short);
    vector<unsigned short> Board(void) const;
    void Restart(void);
    unsigned short State(void) const;
    bool FirstPlayer(void) const;

};

#endif // TICTACTOEENGINE_H


TicTacToeEngine.cpp

Código (cpp) [Seleccionar] Expandir

#include "TicTacToeEngine.h"

//////////////////////////////////////////////////////////////////////////////////////////

// win checker

//checks if there is a line
void TicTacToeEngine::Check(void)
{
    /////////////
    //CHECK TIE//
    /////////////

    unsigned short i = 0;

    while(i < 9 && board[i] != 0) {

        if(i == 8) {
            state = 3;
            return;
        }
        i++;
    }

    //////////////////////
    //CHECK FIRST PLAYER//
    //////////////////////

    //CHECK HORIZONTAL

    //first line
    if(board[0] == 1 && board[1] == 1 && board[2] == 1)
        state = 1;
        return;

    //second line
    if(board[3] == 1 && board[4] == 1 && board[5] == 1)
        state = 1;
        return;

    //third line
    if(board[6] == 1 && board[7] == 1 && board[8] == 1)
        state = 1;
        return;

    //CHECK VERTICAL

    //first line
    if(board[0] == 1 && board[3] == 1 && board[6] == 1)
        state = 1;
        return;

    //second line
    if(board[1] == 1 && board[4] == 1 && board[7] == 1)
        state = 1;
        return;

    //third line
    if(board[2] == 1 && board[5] == 1 && board[8] == 1)
        state = 1;
        return;

    //DIAGONAL LINES

    //top right to bottom left
    if(board[2] == 1 && board[4] == 1 && board[6] == 1 )
        state = 1;
        return;

    //top left to bottom right
    if(board[0] == 1 && board[4] == 1 && board[8] == 1 )
        state = 1;
        return;

    ///////////////////////
    //CHECK second PLAYER//
    ///////////////////////

    //CHECK HORIZONTAL

    //first line
    if(board[0] == 2 && board[1] == 2 && board[2] == 2 )
        state = 2;
        return;

    //second line
    if(board[3] == 2 && board[4] == 2 && board[5] == 2 )
        state = 2;
        return;

    //third line
    if(board[6] == 2 && board[7] == 2 && board[8] == 2 )
        state = 2;
        return;

    //CHECK VERTICAL

    //first line
    if(board[0] == 2 && board[3] == 2 && board[6] == 2 )
        state = 2;
        return;

    //second line
    if(board[1] == 2 && board[4] == 2 && board[7] == 2 )
        state = 2;
        return;

    //third line
    if(board[2] == 2 && board[5] == 2 && board[8] == 2 )
        state = 2;
        return;

    //DIAGONAL LINES

    //top right to bottom left
    if(board[2] == 2 && board[4] == 2 && board[6] == 2 )
        state = 2;
        return;

    //top left to bottom right
    if(board[0] == 2 && board[4] == 2 && board[8] == 2 )
        state = 2;
        return;

    return;
}


//////////////////////////////////////////////////////////////////////////////////////////

// constructors & destructor

//normal constructor
TicTacToeEngine::TicTacToeEngine(void) :
    state(0), first__player_turn(false)
{
    //creates an array filled with 0 (empty board)
    for(int i = 0; i < 9; i++) {
        board.push_back(0);
    }
}

//constructor with vector as argument
TicTacToeEngine::TicTacToeEngine( const vector<unsigned short> original_board) :
    board(original_board), first__player_turn(false)
{
    Check();
}

//copy constructor
TicTacToeEngine::TicTacToeEngine( const TicTacToeEngine& original) :
    board( original.board), state(original.state),
    first__player_turn(original.first__player_turn) {}

TicTacToeEngine::~TicTacToeEngine(void) {}


//////////////////////////////////////////////////////////////////////////////////////////

// operator =

TicTacToeEngine TicTacToeEngine::operator=( const TicTacToeEngine& original)
{
    board = original.board;
    state = original.state;
    first__player_turn = original.first__player_turn;

    return *this;
}


//////////////////////////////////////////////////////////////////////////////////////////

// Movement method

bool TicTacToeEngine::Movement(unsigned short place)
{
    //if the place is not between 0 and 8 or occupied or if the game has finished returns false
    if( place < 0 || place > 8 || board[place] != 0 || state != 0)
        return false;

    //else the place in the board is filled
    if(first__player_turn) {
        board[place] = 1;
    }

    else {
        board[place] = 2;
    }

    //check if the game has ended
    Check();
    first__player_turn = !first__player_turn;

    return true;
}


//////////////////////////////////////////////////////////////////////////////////////////

// Return board method

vector<unsigned short> TicTacToeEngine::Board(void) const
{
    return board;
}


//////////////////////////////////////////////////////////////////////////////////////////

// Restart method

void TicTacToeEngine::Restart(void)
{
    //restarts the board array with all elements at 0
    board.clear();

    for(int i = 0; i < 9; i++) {
        board.push_back(0);
    }

    //restarts game data
    state = 0;
    first__player_turn = true;
}


//////////////////////////////////////////////////////////////////////////////////////////

// Returns true if the game has finished

unsigned short TicTacToeEngine::State(void) const
{
    return state;
}


//////////////////////////////////////////////////////////////////////////////////////////

// Returns true if it is the turn of the first player

bool TicTacToeEngine::FirstPlayer(void) const
{
    return first__player_turn;
}


//////////////////////////////////////////////////////////////////////////////////////////


TicTacToe.h

Código (cpp) [Seleccionar] Expandir

#ifndef TICTACTOE_H
#define TICTACTOE_H

#include <iostream>
#include <windows.h>
#include "TicTacToeEngine.h"

using namespace std;

class TicTacToe : public TicTacToeEngine
{
    void Graphic(unsigned short);

public:
    TicTacToe(void);
    bool GraphicMovement(void);
    void Play(void);
};

/*

base class methods:

    TicTacToeEngine(void);
    TicTacToeEngine( const vector<unsigned short>);
    TicTacToeEngine( const TicTacToeEngine&);
    ~TicTacToeEngine(void);
    TicTacToeEngine operator=( const TicTacToeEngine&);

    bool Movement(unsigned short);
    vector<unsigned short> Board(void) const;
    void Restart(void);
    unsigned short State(void) const;
    bool FirstPlayer(void) const;

*/

#endif // TICTACTOE_H

TicTacToe.cpp

Código (cpp) [Seleccionar] Expandir

#include "TicTacToe.h"

//////////////////////////////////////////////////////////////////////////////////////////

// constructors & destructor

//normal constructor
TicTacToeEngine::TicTacToeEngine(void) :
    state(0), first__player_turn(false)
{
    //creates an array filled with 0 (empty board)
    for(int i = 0; i < 9; i++) {
        board.push_back(0);
    }
}


//////////////////////////////////////////////////////////////////////////////////////////

// Graphic Movement

void TicTacToe::Graphic(unsigned short i)
{
    if(board[i] == 0) {
        cout << " ";
    }

    if(board[i] == 1) {
        cout << "x";
    }

    if(board[i] == 2) {
        cout << "O";
    }
}

bool TicTacToe::GraphicMovement(void)
{
    system("CLS");

    cout << endl << endl;
    cout << "   "; Graphic(0); cout << " | "; Graphic(1); cout << " | "; Graphic(2); cout << endl;
    cout << "  ------------" << endl;
    cout << "   "; Graphic(3); cout << " | "; Graphic(4); cout << " | "; Graphic(5); cout << endl;
    cout << "  ------------" << endl;
    cout << "   "; Graphic(6); cout << " | "; Graphic(7); cout << " | "; Graphic(8); cout << endl;
    cout << endl << endl;

    cout << "Movimiento del jugador";

    if(first__player_turn)
        cout << " 1: ";

    if(!first__player_turn)
        cout << " 2: ";

    unsigned short movement;
    bool moved;
    cin >> movement;

    moved = Movement(movement);

    return moved;
}


//////////////////////////////////////////////////////////////////////////////////////////

//Just play

void TicTacToe::Play(void)
{
    while(state == 0) {
        GraphicMovement();
    }

    cout << endl << endl << "End of the game." << endl << endl << "Result: ";

    if(state == 1) {
        cout << "First player has won." << endl << endl;
    }

    if(state == 2) {
        cout << "Second player has won." << endl << endl;
    }

    if(state == 3) {
        cout << "Tie" << endl << endl;
    }
}


//////////////////////////////////////////////////////////////////////////////////////////


y al hacer

Código (cpp) [Seleccionar] Expandir

ficha[i] = new CFicha
no estoy usando punteros solamente?

Awww dios, que error más tonto el primero 
Respecto al segundo, mi intención es crear un puntero de una clase base para almacenar en el un objeto de una clase derivada de esta. En algún libro de POO he visto que hacen eso y me suena que era algo por el estilo de lo que estoy haciendo yo .-.

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 (cpp) [Seleccionar] Expandir

class CBiblioteca
{
   vector<CFicha *> ficha;
   
   public:
       //basico
       CBiblioteca();
       CBiblioteca(const CBiblioteca&);
       ~CBiblioteca();
       CBiblioteca operator=(const CBiblioteca&);
       CFicha* operator[](unsigned);

       //funciones
       void AnyadirFicha(CFicha&);
       int BuscarFicha(const string) const;
       //eliminar siguiente ?
       bool EliminarFicha(unsigned);
       bool MostrarFicha(unsigned);
       bool MostrarBiblioteca(void);
};
Mi problema se da en el método 'operator=' y 'AnyadirFicha()', los cuales son definidos así:

Código (cpp) [Seleccionar] Expandir

CBiblioteca CBiblioteca::operator=(const CBiblioteca& bib)
{
   //primero vaciamos la matriz
   for(int i = 0; i < ficha.size(); i++)
       delete ficha[i];

   ficha.clear();

   //ahora copiamos los elementos
   for(int i = 0; i < bib.ficha.size(); i++)
       ficha.push_back(new CFicha(*(bib.ficha[i])));

   return *this;
}
y

Código (cpp) [Seleccionar] Expandir

void CBiblioteca::AnyadirFicha(CFicha& ficha)
{
   ficha.push_back(new CFicha(ficha));
}
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.

Gracias a ambos

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 (cpp) [Seleccionar] Expandir

private:
    int tamanyo;
    float array [tamanyo];
y hacerle a la clase un constructor asi:

Código (cpp) [Seleccionar] Expandir

Clase::Clase(int _tamanyo) : tamanyo (_tamanyo)
pero el compilador me da error... Alguien puede indicarme la forma correcta de hacerlo?