Mensajes

Buenas Noches,
Estoy realizando en xo o tic tac toe en c++. Mi programa funciona bien hasta ahora pero mi unico problema es al intercambiar los jugadores. Si alguien me puede señalar el error se los agradeceria mucho

les dejo el codigo:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <cstdlib>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <windows.h>


using namespace std;


int auxiliar;
bool turno ;
class Nodo{
public:
char valor;
    int Index;
    Nodo *sigPtr;
    Nodo *antrPtr;
    Nodo *arrPtr;
    Nodo *abaPtr;

Nodo(char val){
valor=' ';
        //indice a -1
        Index = val;
        //se le mandara al nodo el numero de indice
        sigPtr = 0;
        antrPtr = 0;
        arrPtr = 0;
        abaPtr = 0;
    }
};

class Lista{
private:

public:
    Nodo *PrimeroPtr;
    Nodo *UltimoPtr;
    int tamano;

Lista(){
PrimeroPtr=UltimoPtr=0;
        tamano=0;
    }

bool IsEmpty(){
        return PrimeroPtr==0;
    }

void InsertAtEndDbl(int val){
Nodo *nuevoPtr=new Nodo(val);

if (IsEmpty()){
PrimeroPtr = UltimoPtr = nuevoPtr;
}else{
UltimoPtr->sigPtr = nuevoPtr;
      nuevoPtr->antrPtr = UltimoPtr;
      UltimoPtr = nuevoPtr;
      tamano++;
}
}

void createListX0(){
for(int i=1; i<=9; i++){
InsertAtEndDbl(i);
}

Nodo * anttemp = PrimeroPtr;
    Nodo *actual = PrimeroPtr;

for(int j=1; j<=9; j++){
actual = actual->sigPtr;

if(j>2&&j<9){
anttemp->abaPtr = actual;
            actual->arrPtr = anttemp;
            anttemp = anttemp->sigPtr;         
        }               
    } 
}
   
void Imprimir(){
cout<<" "<<endl;
if(IsEmpty()){
        cout<<"Vacio"<<endl;
    }else{
Nodo *Actual=PrimeroPtr;
        cout<<"["<<Actual->valor<<"] ";
        while(Actual->sigPtr!=0){
            Actual=Actual->sigPtr;
            cout<<"["<<Actual->valor<<"] ";
            if(Actual->Index==3 && Actual->Index<=9 || Actual->Index==6 && Actual->Index<=9){
                cout<<endl;
            }
        }
    }
}

void LlenarJugador1(int posicion){
char simbolo = 'X';
Nodo *actual=PrimeroPtr;
int auxiliar = 0;

if(posicion == 1){
actual->valor = simbolo;
auxiliar++;
}
else if(posicion == 2){
actual->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 3){
actual->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 4){
actual->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 5){
actual->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 6){
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 7){
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 8){
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else{
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
turno == false;
} 

void LlenarJugador2(int posicion){
char simbolo = '0';
Nodo *actual=PrimeroPtr;
int auxiliar = 0;

if(posicion == 1){
actual->valor = simbolo;
auxiliar++;
}
else if(posicion == 2){
actual->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 3){
actual->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 4){
actual->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 5){
actual->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 6){
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 7){
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else if(posicion == 8){
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
else{
actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor = simbolo;
auxiliar++;
}
turno == true;
} 

void Gane(){
Nodo *actual=PrimeroPtr;

//GANE HORIZONTAL
if (actual->valor == 'X' && actual->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->valor == 'X') {
cout<<"Gano de manera Horizontal"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->valor=='0' && actual->sigPtr->valor == '0' && actual->sigPtr->sigPtr->valor=='0')
{
cout<<"Gano de manera Horizontal"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->sigPtr->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X'){
cout<<"Gano de manera Horizontal"<<endl;
}
if(actual->sigPtr->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0'){
cout<<"Gano de manera Horizontal"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X' &&  actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor =='X'){
cout<<"Gano de manera Horizontal"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0' &&  actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor =='0'){
cout<<"Gano de manera Horizontal"<<endl;
auxiliar =9;
system("PAUSE");
}


//GANE DIAGONAL
if(actual->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor =='X'){
cout<<"Gano de manera Diagonal"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor =='0'){
cout<<"Gano de manera Diagonal"<<endl;
system("PAUSE");
}
if(actual->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X'){
cout<<"Gano de manera Diagonal";
auxiliar = 9;
system("PAUSE");
}
if(actual->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0'){
cout<<"Gano de manera Diagonal"<<endl;
auxiliar =9;
system("PAUSE");
}

//GANE VERTICAL
if(actual->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == 'X'){
cout<<"Gano de manera vertical"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->valor == '0' && actual->sigPtr->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == '0'){
cout<<"Gano de manera vertical"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == 'X'){
cout<<"Gano de manera vertical"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == '0'){
cout<<"Gano de manera vertical"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == 'X' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == 'X'){
cout<<"Gano de manera vertical"<<endl;
auxiliar =9;
system("PAUSE");
}
if(actual->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->valor == '0' && actual->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr->sigPtr-> valor == '0'){
cout<<"Gano de manera vertical"<<endl;
auxiliar =9;
system("PAUSE");
}
}

   
friend ostream &operator<<(ostream &os, Lista &l){
    if(l.IsEmpty()){
        return os;
        Nodo *actPtr=l.PrimeroPtr;
        cout<<actPtr->valor<<endl;
        while(actPtr->sigPtr!=0){
            actPtr=actPtr->sigPtr;
            cout<<"->"<<actPtr->valor;
        }
        return os;
    };
}
};

int main(){
system("CLS");
system("Color 8F");
bool seguir = true;

string opcion;
int posicion;

Lista l=Lista();
l.createListX0();
cout<<"--------------------------------- Tic Tac Toe ---------------------------------"<<endl;
while(auxiliar<=3){
if(turno == true){
cout<<"Ingrese posicion: ";
cin>>posicion;
l.LlenarJugador1(posicion);
l.Imprimir();
l.Gane();
auxiliar++;
cout<<"\n";
cout<<"\n";
}
else if(turno == false){
cout<<"Ingrese posicion: ";
cin>>posicion;
l.LlenarJugador2(posicion);
l.Imprimir();
l.Gane();
auxiliar++;
cout<<"\n";
cout<<"\n";

system("PAUSE");
}
}
return 0;
}


Muchas Gracias!
Am, estuve intentando y si, tuve que crear una variable de tamaño la cual incrementa cuando inserto y disminuye cuando elimino. Logre que inserte en medio, pero solo cuando ingreso tres numeros. Si agrego mas, cuando intento ingresar en medio lo coloco detras del primero.

Código (cpp) [Seleccionar] Expandir


void InserteAlMedio(string elemento){
Nodo *temporal = new Nodo(elemento);
if(Vacio() == true){
primero=ultimo=temporal;
}
else{
/*temporal->siguiente = primero;
primero->anterior = ultimo;
temporal->anterior = primero;
//primero->anterior = temporal->siguiente;
primero->anterior = temporal; */


/*primero->anterior = ultimo;
ultimo->anterior = temporal;
temporal->siguiente = temporal->anterior;  */


/*primero->siguiente->anterior = temporal;
temporal->siguiente = primero->anterior;
temporal->anterior = primero;
primero->siguiente = temporal; */

primero->siguiente-> anterior = temporal;
temporal->siguiente = primero->siguiente;
temporal->anterior = primero;
primero->siguiente = temporal;

tamano++;
}
}



void EliminarAlMedio(){
if(Vacio() ==  true){
cout<<"Lista vacia, no puede eliminar."<<endl;
}
else{
//if(primero == ultimo)

if (tamano == 0){
Nodo *temporal = primero->siguiente;
delete primero;
primero = temporal;
primero->anterior = NULL;

//primero = ultimo = NULL;
//Cuando se tiene mas de un nuedo, este se marca con una variable temporal.
}
else{
Nodo *temporal = primero;
for(int i=0; i<tamano; i++){
primero->siguiente->anterior = primero->anterior;
primero->anterior->siguiente = primero->siguiente;

delete temporal;
//Elimina
cout<<"Dato eliminado"<<endl;

tamano--;


/*}
primero->siguiente->anterior = primero->anterior;
primero->anterior->siguiente = primero->siguiente;

delete temporal;
//Elimina
cout<<"Dato eliminado"<<endl;

tamano--; */
}

}
}
}


Buenas Tardes!
Estoy trabajando con C++, listas doblemente enlazada. Nos pidieron ingresar al incicio, enmedio y al final, de los cuales ya logre realizar el insertar al inicio y al final. Mi problema es, ¿Como inserto en medio?
Me dijeron que es necesario un contador el cual no implemente y no se que tan cierto sera.

Le comparto algo del codigo que ya tengo realizado:


De antemano muchas gracias

Uhmm como haria eso?

Averigue que esto se puede realizar con dos ciclos for. No se que tan bien saldra.

Si, lo se. Creeme que quise hacerlo con arreglo, seria mas sencillo. LE punto es que se me exige usar una lista enlazada, lo cual no le encuentro el sentido. No sabria como enlazar los 81 nodos.

en serio si me ayudan se los agradeceria.

Hola, ni yo misma tengo idea. Es un proyecto que me han dejado de tarea y la verdad no se ni por donde empezar.

Hola a todos!
Necesitaba saber como enlazar nodos con listas enlazadas simples. Si alguien me podria explicar se los agradeceria ya que tengo que enlazar 81 O.o
Esto realizando un sudoku.

De antemano, muchas gracias.

Buen día a todos!
Estoy rezando un proyecto con listas enlazadas simples en c++, pero tengo algunas dudas al momento de insertar en medio de la lista. El trabajo me pide que inserte al principio, enmedio y final un determinado dato que ingrese el usuario pero por mas que pruebe no logro ingresar enmedio.

Les adjunto lo que llevo hasta ahorita y les agradeceria mucho si me ayudan a salir de este apuro.

Código (cpp) [Seleccionar] Expandir


void InserteAlInicio(ListaSimple &ls, int dato){
system("CLS");
cout<<"\n";
cout<<"Ingrese numero de inicio: ";
cin>>dato;
cout<<"\n";
ListaSimple valor;
valor = new(struct nodo);
valor->numero = dato;
valor->puntero = ls;
ls = valor;
}



void InserteEnmedio(ListaSimple &ls, int dato){
system("CLS");
cout<<"\n";
cout<<"Ingrese numero de en medio: ";
cin>>dato;
cout<<"\n";
ListaSimple valor, valor2;
valor = new(struct nodo);
valor->numero = dato;
valor->puntero = valor2->puntero;
valor2->puntero = valor;
ls = valor;
}

void InserteAlFinal(ListaSimple &ls, int dato){
system("CLS");
cout<<"Ingrese numero de final: ";
cin>>dato;
ListaSimple valor, valor2;
valor = new(struct nodo);
valor->numero = dato;
valor->puntero = ls;
valor->puntero = NULL;

if(ls==NULL){
ls = valor;
}else{
valor2 = ls;
while(valor2->puntero!=NULL){
valor2 = valor2->puntero;
}
valor2->puntero = valor;
}
}



Hola, buenas tardes!

Necesito ayuda para trancribir esta linea de codigo de java a c++, es un arraylist y en la tarea que nos dejaron era trancribirlo todo a c++ y estoy mas que trabada con esto. en serio, les agradeceria mucho su ayuda

Código (cpp) [Seleccionar] Expandir


public static ArrayList integrantes = new ArrayList();

public static void main(){
}


Buenas Noches!

Necesito aclarar una duda con respecto al uso del virtual y super. Estoy trabajando con Herencia y Polimorfismo en C++

El codigo que estoy trabajando es este

Código (cpp) [Seleccionar] Expandir


class Futbolista: virtual public SeleccionFutbol{
private: int dorsal;
private: int demarcacion;

public: Futbolista(){
super.Futbolista;
}

//getter y setter

void jugarPartido(){

}

void entrenar(){

}

};


Si me podrian señalar mi error se los agradeceria mucho