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;
    }
}
 
 
//////////////////////////////////////////////////////////////////////////////////////////
 

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.

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?

Hola

He escrito la siguiente funcion que se supone que debe cargar un vector de un archivo y retornarlo

vector<long int> Cargar (void)//carga el vector del archivo y lo devuelve
{
    ComprobarArchivo();
    vector<long int> cargar;
    ifstream leer; leer.open("Numeros.dat", ios::in |ios::binary);
    leer.read((char *) &cargar, sizeof cargar);
    return cargar;
}

pero cuando la llamo desde la siguiente linea de codigo

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...

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:

long int cantidadAlmacenar = 0;
struct guardarArchivo{
    long int cantidad = cantidadAlmacenar;
    long int numero [cantidad] = {0};
};

Y la funcion que transforma la estructura dinámica en el array (en verdad es un método de una clase)es la siguiente:

void CCifras::guardarArchivo(void)
{
    struct guardarArchivo guardar;
    struct nodo* guia = comienzo;
    for(int i = 0; i < cantidad; i++)
    {
        guardar.numero[i] = guia.numero;
        guia = guia.siguiente;
    }
    ofstream ficheroEscribir; ficheroEscribir.open ("BaseDatos.dat", ios::out | ios::binary);
    ficheroEscribir.write((char *) &guardar, sizeof(guardar));
    ficheroEscribir.close();
}

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

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

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...

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

#include <iostream>
#include "CPolinomio.h"
 
using namespace std;
 
int main()
{
    CPolinomio p1(5,7);
    CPolinomio p2(3,6);
    CPolinomio p3;
 
    p1.asignarTermino(4,5);
    p1.asignarTermino(10,3);
    p2.asignarTermino(4,3);
    p2.asignarTermino(5,5);
    p2.mostrarPolinomio(); cout << " + ";
    p1.mostrarPolinomio(); cout << endl;
    p3 = p1 + p2; cout << endl;
    (p1 + p2).mostrarPolinomio(); cout << endl;
    p2.mostrarPolinomio();
    //p2 = p1 + p1 + p1;
    //p2.mostrarPolinomio();
    //(p1+p1).mostrarPolinomio();
 
    return 0;
}
 

CTermino.h

#ifndef CTERMINO_H
#define CTERMINO_H
 
 
class CTermino
//Cada uno de los terminos del polinomio
{
private:
    double coeficiente;
    int exponente;
public:
    CTermino(double = 0, int = 0);
    void asignarCoeficiente (double);
    void asignarExponente (int);
    double obtenerCoeficiente (void) const;
    int obtenerExponente (void) const;
    void mostrar(void) const;
};
 
#endif // CTERMINO_H
 

CTermino.cpp

#include "CTermino.h"
#include <iostream>
 
CTermino::CTermino(double c, int e) :
coeficiente(c), exponente(e)
{
    if(e < 0){exponente = -e;}
}
 
void CTermino::asignarCoeficiente (double c) {coeficiente = c;}
 
void CTermino::asignarExponente (int e)
{
    if(e < 0){exponente = -e;}
    else{exponente = e;}
}
 
double CTermino::obtenerCoeficiente (void) const {return coeficiente;}
 
int CTermino::obtenerExponente (void) const {return exponente;}
 
void CTermino::mostrar(void) const//es muy enrrevesado para mostrar los terminos como se suele hacer en algebra...
{
    if(!(coeficiente >= 0)){std::cout << " ";}
    if(coeficiente > 0) std::cout << " +";
    if(coeficiente != 1 && coeficiente != -1) {std::cout << coeficiente;}
    if(coeficiente == -1 && exponente == 1) std::cout << "-";
    if(exponente > 0)
    {
        if(exponente == 1) std::cout << "x";
        else std::cout << "x^" << exponente;
    }
}

CPolinomio.h

#ifndef CPOLINOMIO_H
#define CPOLINOMIO_H
#include "CTermino.h"
 
 
class CPolinomio
{
private:
    CTermino* termino;
    int grado;
    void crearPolinomio (int);
    void ampliar (int);
public:
    CPolinomio(double = 0,int = 0);
    ~CPolinomio();
    int obtenerGrado (void) const;
    void asignarTermino (double , int);
    void mostrarPolinomio(void) const;
    const CPolinomio operator=(const CPolinomio&);
    const CPolinomio operator+(const CPolinomio&) const;
    const CPolinomio operator*(const CPolinomio&) const;
};
 
#endif // CPOLINOMIO_H
 

CPolinomio.cpp

#include "CPolinomio.h"
#include <iostream>
 
CPolinomio::CPolinomio(double c, int e)//Constructor que crea la matriz de terminos del tamaño necesario
{
    grado = e; if(e < 0) {grado = -e;}//si el exponente es negativo lo cambia
    crearPolinomio(e);
    termino[e].asignarCoeficiente(c);//asigna el coeficiente al exponente correcto
}
 
void CPolinomio::crearPolinomio(int g)//crea la matriz de objetos termino del tamaño necesario
{
    delete [] termino; termino = new CTermino [g+1];
    for (int i = 0; i <= g; i++) termino[i].asignarExponente(i);
}
 
void CPolinomio::ampliar (int g)//amplia la matriz terminos al tamaño pasado por parametro
{
    double coeficientes [grado+1];
    for(int i = 0; i <= grado; i++) coeficientes [i] = termino[i].obtenerCoeficiente();//copia los terminos en una matriz
    crearPolinomio(g);
    for (int i = 0; i <= grado; i++) termino[i].asignarCoeficiente(coeficientes [i]);//copia los terminos de vuelta al nuevo array
    grado = g;
}
 
CPolinomio::~CPolinomio()
{
    delete [] termino;
}
 
int CPolinomio::obtenerGrado(void) const {return grado;}
 
void CPolinomio::asignarTermino(double c, int e)
{
    if(e < 0) return;//SI NO ES VALIDO NO HACE NADA
    if(e > grado)//SI EL EXPONENTE ES MAYOR QUE EL GRADO CREA UN NUEVO POLINOMIO ADECUADO
    {
        ampliar(e);
        termino[e].asignarCoeficiente(c);
    }
    else {
        termino[e].asignarCoeficiente(c);//SI TODO ES NORMAL SIMPLEMENTE LO CAMBIA
    }
}
 
void CPolinomio::mostrarPolinomio(void) const//funcion que muestra el polinomio
{
    std::cout << "(";
    for(int i = grado; i > 0; i--) {if(termino[i].obtenerCoeficiente() != 0)termino[i].mostrar();}
    if(termino[0].obtenerCoeficiente() != 0) termino[0].mostrar();
    std::cout << ")";
}
 
const CPolinomio CPolinomio::operator=(const CPolinomio& pol)//operador =
{
    grado = pol.grado;
    ampliar(pol.grado);
    for(int i = 0; i <= pol.grado; i++) termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente());
}
 
const CPolinomio CPolinomio::operator+(const CPolinomio& pol) const//operador +
{
 
    if(grado == pol.grado)//si ambos grados son iguales (no hay que ampliar)
    {
        CPolinomio resultado(0, grado);
        for(int i = 0; i <= resultado.grado; i++)
        {
            resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente() + termino[i].obtenerCoeficiente());
        }
        resultado.mostrarPolinomio();//codigo experimental para saber si el error es al devolver el objeto
        return resultado;
    }
    else {
        if(grado > pol.grado)//si uno de los polinomios tiene mas grado
        {
            CPolinomio resultado(0, grado);
            for(int i = 0; i <= pol.grado; i++)
            {
                resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente() + termino[i].obtenerCoeficiente());
            }
            for(int i = pol.grado+1; i <= grado; i++) resultado.termino[i].asignarCoeficiente(termino[i].obtenerCoeficiente());
            resultado.mostrarPolinomio();//codigo experimental para saber si el error es al devolver el objeto
            return resultado;
        }
        if(grado < pol.grado)//si el otro polinomio es mayor
        {
            CPolinomio resultado(0, pol.grado);
            for(int i = 0; i <= grado; i++)
            {
                resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente() + termino[i].obtenerCoeficiente());
            }
            for(int i = grado+1; i <= pol.grado; i++) resultado.termino[i].asignarCoeficiente(pol.termino[i].obtenerCoeficiente());
            resultado.mostrarPolinomio();//codigo experimental para saber si el error es al devolver el objeto
            return resultado;
        }
    }
}
 
const CPolinomio CPolinomio::operator*(const CPolinomio& pol) const//operador *
{
    int gr = pol.grado*grado;
    CPolinomio resultado(gr);
 
    for (int i = 0; i <= grado; i++)
    {
        if(termino[i].obtenerExponente() != 0)
        {
            CPolinomio calculos;
            for(int x = 0; x <= pol.grado; x++)
            {
                calculos.asignarTermino(termino[i].obtenerCoeficiente() * pol.termino[x].obtenerCoeficiente(), termino[i].obtenerExponente() + pol.termino[x].obtenerExponente());
            }
            resultado = resultado + calculos;
        }
    }
 
    return resultado;
}

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...

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.

Hola, he hecho un pequeño programa para acompañar mi pregunta

main.cpp

#include <iostream>
 
using namespace std;
 
int main()
{
    clase miClase(42);
    miClase.mostrar();
    return 0;
}
 

clase.h

#ifndef CLASE_H
#define CLASE_H
#include <iostream>
 
class clase
{
private:
    int numero;
public:
    clase (int n=0);
    void mostrar(void) const;
};
 
#endif // CLASE_H

clase.cpp

#include "clase.h"
#include <iostream>
 
clase::clase (int n) : numero(n){}
 
void clase::mostrar(void) const
{
    cout << numero << endl;
}
 

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