Temas

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


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


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.

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?

Hola

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

Código (cpp) [Seleccionar] Expandir

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

Código (cpp) [Seleccionar] Expandir

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:

Código (cpp) [Seleccionar] Expandir

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:

Código (cpp) [Seleccionar] Expandir

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

Código (cpp) [Seleccionar] Expandir

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

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

#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

Código (cpp) [Seleccionar] Expandir

#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

Código (cpp) [Seleccionar] Expandir

#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

Código (cpp) [Seleccionar] Expandir

#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

Código (cpp) [Seleccionar] Expandir

#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

Código (cpp) [Seleccionar] Expandir

#include <iostream>

using namespace std;

int main()
{
    clase miClase(42);
    miClase.mostrar();
    return 0;
}


clase.h

Código (cpp) [Seleccionar] Expandir

#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

Código (cpp) [Seleccionar] Expandir

#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   

Hola

Tengo un problema al crear una conexion de puente entre mi Pc y mi PS3 (con el fin de darle conexion a internet a esta mediante un cable de Ethernet), y es que cuando entro en Panel de Control>Redes e Internet>Conexiones de Red y selecciono mi red wifi y el icono del cable Etheret, clic derecho y conexiones de puente, me sale el siguiente mensaje:
"Para crear un puente de red debe seleccionar por lo menos dos o mas conexiones a Internet de alta velocudad o LAN que no esten siendo usadas por Conexion compartida a Internet"
Y por ello no puedo crear el puente...
Alguien sabe que puede estar pasando? Gracias de antemano

Hola.
Tengo un problema, y es que cada vez que abro un juego (Prepar3D) el .NetFramework me da un error que dice:

Establezca la clave
HKLM\Software\Microsoft\.NETFramework\InstallRoot del registro
para que apunte a
la ubicación de instalación de .NET Framework

No se que hacer para solucionarlo; he abierto el regedit y he ido a la ruta que me indica y en el fichero InstallRoot está la ruta:

C:\Windows\Microsoft.NET\Framework64\

Si alguien puede ayudarme...
Gracias!

Hola!
Pues eso, me gustaría saber como puedo iniciar otro programa desde el mio, por ejemplo, hacer un programa que ejecute el Paint (o lo que sea XD) y también si se puede interactuar con el, por ejemplo: ejecutar un programa que ejecute otro que te pida un numero (por ejemplo) y que el propio programa introduzca el numero; no se si me explico, pero lo principal sería lo primero hahaha
Gracias!

Hola!
He probado a cambiar el color del texto de mi programa, pero al ejecutarlo me da error "error: FOREGROUND was not declared on this scope" no entiendo por que el compilador entiende que foreground es una variable. Alguien puede ayudarme y decirme de paso si hay algún método más simple para cambiar el texto de color?
Gracias!

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <windows.h>
using namespace std;

int main()
{
    HANDLE h=GetStdHandle( STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(h,FOREGROUND_BLUE |FOREGROUND INTENSITY);
    cout<<"Blue"<<endl;
    SetConsoleTextAttribute(h,FOREGROUND_RED |FOREGROUND INTENSITY);
    cout<<"Red"<<endl;
    SetConsoleTextAttribute(h,FOREGROUND_GREEN |FOREGROUND INTENSITY);
    cout<<"Green"<<endl;

    cin.get();
    return 0;
}


Hola!
Estoy haciendo un juego de una nave que debe esquivar asteroides que se acercan.
Para provocar que se acerquen hice que cada vez la x de estos sean menores, pero no se por que no funciona... He aquí el código; un saludo! (la parte que falla (que yo crea) es la que esta comentada como ASTEROID MOVEMENT (linea 20))

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <conio.h>
#include <windows.h>
using namespace std;
bool gameOver;
const int width=20;
const int height=10;
int x, y, astdX=width-1, astdY,asteroidYrand, score;
enum eDirection {STOP=0, UP, DOWN};
eDirection dir;

void Setup()
{
   gameOver=false;
   dir=STOP;
   x=5;
   y=height/2;
   //ASTEROID MOVEMENT
   if(astdX==width-1){astdY=1+rand()%8;}
   if(astdX!=width&&astdX!=0){astdX--;}//ESTO DEBERIA HACER QUE LA X FUESE CADA VEZ MENOR, ES DECIR, QUE EL ASTEROIDE SE FUESE ACERCANDO
   if(astdX==0){astdX=width-1;}

}

void Draw()
{
   system("cls");
   for(int i=0;i<height+1;i++)
   {
       if(i==0)
       {
           for(int j=0;j<width+1;j++)
           {
               cout<<"#";
               if(j==width){cout<<endl;}
           }
       }
       if(i>0&&i<height)
           {
               for(int j=0;j<width+1;j++)
           {
               if(j==0){cout<<"#";}
               if(j>0&&j<width)
               {
                   if(i!=y){cout<<" ";}
                   if(j<5&&i==y){cout<<" ";}
                   if(j==5&&i==y){cout<<">";}
                   if(j>5&&i==y){cout<<" ";}
               }
               if(j==width){cout<<"#"<<endl;}
           }
           }
       if(i==height)
       {
           for(int j=0;j<width+1;j++)
           {
               cout<<"#";
               if(j==width){cout<<endl;}
           }
       }
   }
   cout<<"Score: "<<score<<endl;
   cout<<"astdY: "<<astdY<<endl<<"astdX: "<<astdX<<endl<<"Rand: "<<(1+rand()%8)<<endl;
}

void Input()
{
   if(_kbhit())
   {
       switch(_getch())
       {
       case 'w':
           dir=UP;
           break;
       case 's':
           dir=DOWN;
           break;
       case 'x':
           gameOver=true;
           break;
       }
   }
}

void Logic()
{
   switch(dir)
   {
   case UP:
       y--;
       break;
   case DOWN:
       y++;
       break;
   default:
       break;
   }
   if(y==1||y==height-1){dir=STOP;}
   if(y==0||y==height){y=height/2;}
   if(x==astdX&&y==astdY){gameOver=true;}
   if(x==astdX&&y!=astdY){score+=10;}
}

int main()
{
   Setup();
   while(!gameOver)
   {
       Draw();
       Input();
       Logic();
       Sleep(100);
   }
   return 0;
}


Hola de nuevo!
Estaba haciendo un pequeño juego (el de snake) y para hacer que la serpiente se mueva simplemente hago que la pantalla se limpie y se vuelva a dibujar todo con las nuevas coordenadas de la serpiente y asi todo el rato, pero el problema es que como el programa se carga muy rápido, la rserpiente va suuuper rapido y no es posible manejarla de forma facil. Hay alguna forma de hacer que el programa espere un x tiempo (en este caso de unas centesimas) antes de volver a cargar todo? No se si me explico...
Un saludo

Hola!
He estado aprendiendo sobre los punteros pero no se en que se usan, no les veo una utilidad real. Alguien podría explicarme de que modo se usan en un programa y si es posible un pequeño ejemplo?
Gracias.

Hola!
Pues eso, hoy me puse a hacer un pequeño programa que suma y resta dos números y no me deja devolver a main dos valores de otra función con return.
Además de esto, me gustaría saber si hay alguna manera de que al final del programa, si el usuario elige repetir programa, el programa vuelva al principio (en este caso, a menu1, no se si me explico).
Un saludo!

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using namespace std;

int Menu1 (int numero1, int numero2);
void Menu2 (int suma,int resta);
int MenuFinal ();

int main ()
{
    int numero1;//PRIMER NUMERO INTRODUCIDO
    int numero2;//SEGUNDO NUMERO INTRODUCIDO
    int suma;//PRODUCTO DE LA SUMA DE AMBOS
    int resta;//PRODUCTO DE LA RESTA DE AMBOS
    int opcion;//OPCION ELEGIDA (1 O 2) EN LA FUNCION "MENU FINAL"

    Menu1(numero1,numero2);
    suma=numero1+numero2;
    resta=numero1-numero2;
    Menu2 (suma,resta);
    opcion=MenuFinal();
    //AQUI QUIERO PONER UN COMANDO PARA QUE VUELVA A "MENU1"

    return 0;
}

int Menu1 (int numero1, int numero2)
{
    cout<<"Introduce dos numeros"<<endl<<"Numero 1: ";
    cin>>numero1;
    cout<<"Numero 2: ";
    cin>>numero2;

    return numero1;
    return numero2;
}

void Menu2 (int suma,int resta)
{
    cout<<"Producto de la suma = "<<suma<<endl;
    cout<<"Producto de la resta = "<<resta<<endl;
}

int MenuFinal ()
{
    int opcion;
    cout<<endl<<"---------------"<<endl<<"Final del programa, opciones:"<<endl;
    cout<<"1-> Repetir programa."<<endl<<"2-> Salir del programa."<<endl;
    cin>>opcion;
    return opcion;
}


Hola!
Pues ayer estaba configurando mi cuenta (soy nuevo en el foro) y vi que se podían poner fotos personalizadas, pero te pide una especie de link y ando algo perdido 
Alguien podría indicarme como poner tus propias fotos de perfil?
Gracias!

Hola!
Hoy trate de hace un programa que pide una contraseña al ejecutarlo y trate de hacer una función la cual se encarga de registrar la contraseña que ingresa el resultado (como una variable de string) y devolverla (mediante return) a main para que este a su vez se lo pase a otra función y etc... pero cuando trato de compilar lo que llevo programado hasta ahora me da el siguiente error en la línea 40:
error: cannot convert 'std::string {aka std::basic_string<char>}' to 'int' in return
Supongo que se deberá a un fallo a la hora de devolver el valor, pero no se que hacer...

PDA: Me gustaría también que el programa informase de un error y se cerrase si se superan los 5 intentos y no se si lo hice bien, podrían decirme ya de paso?
Gracias!

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

int PassMenu (string answer, int atmps);
int Password (string answer, string pass);

int main ()
{

    string answer;//ES LA RESPUESTA QUE DA EL USUARIO
    string pass;//ES LA CONTRASEÑA
    bool access;//DICE SI LA CONTRASEÑA ES TRUE/FALSE
    int atmps=6;//VECES QUE SE HA INTRODUCIDO LA CONTRASEÑA

    while(access==false||atmps!=0)//HACE EL MENU DE INTRODUCIR PASS Y CONMPRUEBA SI ESTÁ BIEN
    {
        answer=PassMenu(answer,atmps);
        access=Password(answer, pass);
        atmps--;
    }

    if(atmps==0)//SI SE INTRODUCE MAL LA CONTRASEÑA 5 VECES MAL, EL PROGRAMA IMPIDE SEGUIR INTENTANDOLO Y SE CIERRA
    {
        cout<<"ACCESS DENIED"<<endl;
        system("PAUSE");
        exit (EXIT_FAILURE);
    }

    system("PAUSE");
    return 0;
}


int PassMenu (string answer, int atmps)//ES EL DISEÑO DE CUANDO TE PIDE LA CONTRASEÑA
{
    cout<<endl<<endl<<"Attempts: "<<(atmps-1)<<endl<<"PASS: ";
    cin>>answer;
    return answer;
}


int Password (string answer, string pass)
{

}


Hola amigos!
Soy nuevo en el foro y me gustaría saber si hay alguna forma de ver una lista con los temas que he creado. Gracias!

Hola!
Se que parece estúpido, pero hay una cosa que no acabo de tener clara. Lo cierto es que tengo la idea típica de lo que es un hacker, un "concepto general" y tengo curiosidad por saber mas sobre el mundillo. Pero realmente, ¿Quien es un hacker?, o ¿a que se dedica un hacker? Quiero aclarar que no pido una lista de tareas, sino una explicación/concepto más nítido. Saludos!

Hola!
He hecho un simple programa el cual genera números aleatorios, pero antes tu le indicas un numero que ha de buscar en la lista de números aleatorios, la cantidad de veces que debe buscarlo y el "rango" de números que genera (podríamos decir que lo que tu introduces es arco y luego hace lo siguiente: rand()%arco ).Y bueno, debido a mi poca experiencia programando estaría que me dieseis vuestra opinión y tips para mejorarlo.
Gracias

Código (cpp) [Seleccionar] Expandir


//HECHO POR CNOOB
//18 DE JUNIO DE 2016

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int Errores(bool error,int numero,int veces,int arco);
void Errores2(int errores2);

int main (){

    srand(time(0));
    int numero;
    int veces;
    int arco;
    int x;
    int y=1;
    int i=0;
    int posiciones[i];
    int z=0;
    double h;
    bool error;

    cout << "Numero que se busca: ";
    cin >> numero;
    cout << "Veces que se buscara: ";
    cin >> veces;
    cout << "Rango de numeros (0-x): ";
    cin >> arco;
    cout << endl;

    error=Errores (error,numero,veces,arco);


    if(error==false){
    while(i<veces)
    {
        x=(rand()%(1+arco));
        cout << y << "    " << x << endl;
        cout << "                     Busqueda: " << (1+i) << endl;
        ++y;
        if(x==numero){
            cout << endl;
            cout << "STOP" << endl;
            cout << "Busqueda " << 1+i << "." << endl;
            cout << endl;
            cout << endl;
            ++i;
            z += (y-1);
            y=1;
        }
    }


    h = (z/veces);

    cout << "Numero buscado: " << numero << endl;
    cout << "Veces que se ha buscado: " << veces << endl;
    cout << "Rango de numeros generado: " << arco << endl;
    cout << endl;
    cout << "Media de posiciones en las que se encontro el " << numero << " ->  "<< h << endl;

    Errores2 (h);

    cout << endl;
    }

    system ("PAUSE");
    return 0;
}

int Errores(bool error,int numero,int veces,int arco)
{
    error=false;

    if(numero<0){
        cout << "ERROR!" << endl;
        cout << "No se pueden buscar numeros negativos." << endl;
        cout << endl;
        error=true;
    }

    if(veces<=0){
        cout << "ERROR!" << endl;
        cout << "No se pueden buscar 0 o menos veces." << endl;
        cout << endl;
        error=true;
    }

    if(arco<0){
        cout << "ERROR!" << endl;
        cout << "No se pueden generar rangos negativos." << endl;
        cout << endl;
        error=true;
    }

    if(numero>arco){
        cout << "ERROR!" << endl;
        cout << "No se pueden buscar numeros mayores que el rango." << endl;
        cout << endl;
        error=true;
    }
    return error;
}

void Errores2(int h)
{
    if(h==0){
        cout << "(Es probable que haya sucedido un error, compruebe los valores introducidos.)" << endl;
    }

}


Hola amigos, primer tema que creo.
Bien, lo cierto es que empece a aprender c++ hace algo así como de una semana y no tengo gran idea. Mi pregunta es la siguiente:

He creado un pequeño programa en forma de bucle y quiero saber si hay alguna forma de parar el bucle pulsando una tecla (intro, por ejemplo) y de paso si podéis enseñarme a poner botones en mi programa. He aquí lo que llevo hasta ahora (recordad que soy novato XD):

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <stdlib.h>
#include <cstdlib>
using namespace std;

int main()
{
    int x=0;
    bool flag=true;

    cout<<"Pulsa intro."<<endl;
    cin.get();

    while(flag)
    {
        cout<<x<<endl;
        ++x;
    }
    system("PAUSE");
    return 0;
}