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

#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

#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

#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

#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

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:

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í:

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

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í:

private:
    int tamanyo;
    float array [tamanyo];

y hacerle a la clase un constructor asi:

Clase::Clase(int _tamanyo) : tamanyo (_tamanyo) 

pero el compilador me da error... Alguien puede indicarme la forma correcta de hacerlo?