Saludo a todos !!

estoy aprendiendo alguinas coasa pero me he confundido con algo que realmetne me tiene loco a ver si alguien por favor me aclara :

#ifdef __cplusplus
extern "C"
{
#endif
#include<...>
 
#ifdef __cplusplus
}
#endif

para q

Saludo a todos !!

Con el proposito de aprender estructura de datos estoy haciendo una clase para tener una especie de lista enlazadas , estoy usando template y como todos sabemos los templates se deben definir dentro del mismo header(c++98) entonces le cuento tengo una estructura llamado nodo que esta basada en plantilla y tiene de variables , un puntero al nodo siguiente y el dato a almacenar en esa instancia, luego tengo la clase lista que tiene el nodo a la cabeza de node y tengo una funcion que me devuelve un nodo
el problema me lo da al compilar

es el siguiente :
../src/LinkList.h:66:50: error: invalid cast from type ‘Object’ to type ‘void*’
         head_traits = (T) createNode((void *)data);


me gustaira saber si hay perdidas de datos cuando forzo a compilar  con static_cast<void *> , el codigo solo compilar si uso eso si no es otra cosa. dejare  el codigo...

 
 
#define DEBUG 1
 
Node_traits<void*>* createNode(void *cr_dat)
{
 
#ifdef DEBUG
    clog << "__FUNCTION__"<<__FUNCTION__<<endl;
#endif
 
	Node_traits<void*> *ret = new Node_traits<void*>();
    memcpy(ret->data, cr_dat, sizeof(cr_dat));
    ret->next_ptr_traits = NULL;
    return ret;
}
 
 
 
template<class T>
struct Link_List
{
	int cnt;
    Node_traits<T> *head_traits;
 
 
    void CreateList(T data)
    {
        head_traits = (T) createNode((void *)data);
    }
 
 
 
};
 
 
 
 
 
 
 
 
 
 

gracias de antemano.!!

Saludo para todos!!


les cuento he estado tratando de escribir una clase  pueda leer de una arhivo varios objetos y cuando encuentre el null salga de la func pero lo unico que me da es un par de exceptiones dejare el codigo abajo pienso que es la forma correcta asi pero si alguien me aconseja.

package Data;
 
import Data.InventarioData;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
 
public class ReadData {
	ObjectInputStream inputFile;
 
 
	public ReadData(){}
 
 
	public Object ReadDataFile( String filename)
	{
		Object ret = null;
		try {
			inputFile = new ObjectInputStream(new FileInputStream(filename));
			ret = inputFile.readObject();
		    inputFile.close();
 
		} catch (IOException e) {
 
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
 
		return ret;
	}
 
	public void ReadAllData(String filename)
	{
		InventarioData inv = null;	
 
	 	boolean reading = true;
	 	{
	 		try {
				inputFile = new ObjectInputStream(new FileInputStream(filename));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	 		while( reading == true )
	 		{
 
				try {
					if((inv = (InventarioData ) inputFile.readObject())!= null)
					  {
					      inv.PrintConsole();
					  }
				} catch (ClassNotFoundException e) {
					reading = false;
					e.printStackTrace();
				} catch (IOException e) {
				reading = false;
					e.printStackTrace();
				}
 
	 		}
 
	 	}
 
 
	}
 
}
 

la exception es la siguiente :

at java.io.ObjectInputStream.readObject0(Unknown Source)
	at java.io.ObjectInputStream.readObject(Unknown Source)
	at Data.ReadData.ReadAllData(ReadData.java:50)
	at Main.Main.main(Main.java:23)

tambien me gustaria agregar que la clase inventario Implementa serializable de hecho si leo individualmente un objeto me devuleve bien , pero ahora me estoy preguntado si esta bien el metodo que uso para escrbir el objeto y que append al archivo

ObjectOutputStream fileOutput;
 
... 
            //// no se si hay otra forma de hacerlo.
            fileOutput = new ObjectOutputStream(new FileOutputStream(filename));
	    fileOutput.writeObject(object);
 
 

tambien me gustaria agregar que no estoy usando  la documentacion de oracle simplemente estoy usando algo que tome de una clase y por eso quizas me hace falta algo , soy nuevo en java vengo de c++ , cualquier consejo o critica es bien tomado y agradecido...!!!



gracias de antemano.

se cerraba , pero no lo veo claro , ahora voy tener que apender a usar el GDB por que realmente nunca he depurado, voy a ver que sale en los trace y publico , y descubri que con std::map me hace lo mismo publicare en un par de horas voy a casa a ver si sigo alla ,escribo en un rato. gracias

deja de trabajar en la funcion CopiarTile(swapear)

la salida de cout es

-------------------------------------------------------------------
posicion 416 type 0
posicion 368 type 1
CopiarTilepreparando para copiar 
     x1 : 80
     x1 : 32
     x1 : 0
     x1 : 1
---------------------------------------------------------------------------------------
     x2 : 80
     x2 : 32
     x2 : 0
     x2 : 1
 
 copiar 
     x : 80
     y : 32
 color : 0
----------------------------------------------------------------------------
copiar 
     x2 : 80
     y2 : 32
 color2 : 0
----------------------------------------------------------------------------
 
 
 
 

pero hasta me doy cuenta que lo que hace es lo siguiente los elementos se copian pero como se copian todos los datos quedan igual. estoy pensando cambiar std::map o unordered_map ya que con ellos puedo usar clear() es mas facil copiar segun entiedo.

realmente puse mal el identificador
pero si te fijas en esta linea

 
	Tile *temp1 = tile[index2];
	Tile *temp2 = tile[index1];
.... 
          tile[index1]=temp1;
          tile[index2]=temp2;
 
 

eso seria el intercambio aunque al final la aplicacion explota immediatamente uso el evento.

waooo que sencillo ,gracias aunque me gustaria decir que funcion realmente no
bueno voy a descansar dejare , el codigo completo aqui.

//============================================================================
// Description : Hello World in C++, Ansi-style
//============================================================================
 
#include <SDL2/SDL.h>
 
#include <map>
#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
/*para probar*/
#include <vector>
using namespace std;
 
 
#define RED        0
#define GREEN      1
#define BLUE       2
#define YELLOW     4
#define GRAY       5
#define NONE       6
#define COLOR_QTY  5
#define NOINDEX    -9999
 
SDL_Window   *window = nullptr;
SDL_Renderer *render = nullptr;
int **board  =nullptr;
static int width  = 400;
static int height = 500;
 
SDL_Rect cursor_pos ={0,0,16,16};
 
static int block_size;
static int block_height;
static int nCol   = 0;
static int nRow   = 0;
 
/**Touch and movement*/
static bool oneTimeClicked = true;
static int o1 = NOINDEX;
static int o2 = NOINDEX;
static int getCollide;
 
 
 
 
char title[32];
bool Run  = false;
SDL_Event event;
 
 
 
 
string color_name []=
{
 "red",
 "green",
 "blue",
 "yellow",
 "gray"
 
};
 
const char *filename[] =
{
  "red.bmp",
  "green.bmp",
  "blue.bmp",
  "yellow.bmp",
  "gray.bmp"
 
};
 
 
SDL_Color color[]=
{
 {0xff, 0,0,0xff},
 {0, 0xff,0,0xff},
 {0, 0,0xff,0xff},
 {0xff, 0xff,0,0xff},
 {0x90, 0x90,0x90,0xff}
};
 
struct Tile
{
 
   int x;
   int y;
   int color;
   int index;
   Tile(int x_,int y_, int color_ ,int indexVal)
   :x(x_),y(y_), color(color_), index(indexVal){}
   SDL_Rect getRect()
   {
	   SDL_Rect rect ={x,y,block_size, block_height};
	   return rect;
   }
};
 
 
map<string, SDL_Texture *>texture_list;
vector<Tile *>tile_set;
 
 
void CreateBlocks();
void AlignBlocks();
void CreateBoard();
void DrawBoard();
bool check_collision( SDL_Rect A, SDL_Rect B);
void SwapVectorValue(vector<Tile *>&ref,int index1, int index2);
int isCollide();
 
void CopiarTile(vector<Tile*> &tile, int index1,int index2);
 
 
 
 
int main(int argc, char *argv[])
{
 
 
 
 
 
	SDL_Init(SDL_INIT_EVERYTHING);
 
 
 
 
	window = SDL_CreateWindow("table", SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,
			                   width, height, SDL_WINDOW_SHOWN|SDL_WINDOW_BORDERLESS);
    render = SDL_CreateRenderer(window, -1 , SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
 
 
    CreateBlocks();
	AlignBlocks();
	CreateBoard();
 
 
    Run = (render == NULL  ? false : true);
    while(Run)
    {
    	while(SDL_PollEvent(&event))
    	{
    		if(event.type ==SDL_QUIT)
    		{
    			Run = false;
    		}
    		if(event.type == SDL_MOUSEMOTION)
    		{
    			cursor_pos.x = event.motion.x;
    			cursor_pos.y = event.motion.y;
    		}
            if(event.type == SDL_MOUSEBUTTONDOWN)
            {
                getCollide  =	isCollide();
            	if( getCollide != NOINDEX && oneTimeClicked == true)
                   {
                       o1 =getCollide;
                      /// cout <<"el indice seleccionado es : "<<tile_set[o2]->index<<endl;
                       oneTimeClicked = false;
                    }
            	else if(getCollide != NOINDEX && oneTimeClicked == false)
					{
            		    o2 = getCollide;
            		    //cout <<"El segundo es este"<<tile_set[o2]->index<<endl;
            	    	SwapVectorValue(tile_set,o1, o2);
            	    	oneTimeClicked = true;
            	    	o1 = NOINDEX;
            	    	o2 = NOINDEX;
					}
 
 
            }
 
 
    	}
    	const Uint8* key = SDL_GetKeyboardState(NULL);
		if(key[SDL_SCANCODE_Q])
		{
			Run = false;
		}
 
 
 
 
       SDL_SetRenderDrawColor(render, 0x0,0x0,0x0, 0xff);
       SDL_RenderClear(render);
       DrawBoard();
       SDL_RenderPresent(render);
 
    }
    SDL_DestroyRenderer(render);
    SDL_DestroyWindow(window);
    SDL_Quit();
 
 
	return 0;
}
 
 
 
 
 
 
 
 
 
void CreateBlocks()
{
   SDL_Surface* SurfaceTemp[COLOR_QTY] = {nullptr};
   for(int i(0); i < COLOR_QTY ;i++)
   {
	   SurfaceTemp[i] = SDL_LoadBMP(filename[i]);
	   /*if(SurfaceTemp[i] == NULL) {
	           fprintf(stderr, "CreateRGBSurface failed: %s\n", SDL_GetError());
	           exit(1);
	       }*/
   }
   for(int i(0); i < COLOR_QTY ;i++)
      {
	     SDL_SetColorKey(SurfaceTemp[i],SDL_TRUE ,SDL_MapRGB(SurfaceTemp[i]->format,0,0,0));
   	     texture_list[color_name [i]] = SDL_CreateTextureFromSurface(render ,SurfaceTemp[i]);
      	 SDL_FreeSurface( SurfaceTemp[i]);
      }
   SDL_Surface *cursor = SDL_LoadBMP("cursor.bmp");
   SDL_SetColorKey(cursor,SDL_TRUE ,SDL_MapRGB(cursor->format,0,0,0));
   texture_list["cursor"] = SDL_CreateTextureFromSurface(render ,cursor);
   SDL_FreeSurface(cursor);
 
}
 
 
void AlignBlocks()
{
	srand(time(nullptr));
 
  block_size   = 48;
  block_height = block_size-3;
  for(int i(0); i < height; i += block_size)
  {
	  cout << " i [ "<< i<< "]\n";
	  nRow++;
  }
  for(int k(0);k < width; k +=block_size)
  {
	  cout << " k [ "<< k<< "]\n";
	  nCol++;
  }
  board = new int*[nRow];
  for(int o(0); o < nRow; o++)
    board[o] = new int[nCol];
 
    for(int iter1(0); iter1<nRow; iter1++)
    {
    	 for(int iter2(0); iter2<nCol; iter2++)
    	 {
              board[iter1][iter2] = rand() % YELLOW + RED;
              cout <<"||" <<board[iter1][iter2]<<"||";
    	 }
    	 cout <<"\n";
    }
 
}
 
 
 
 
void CreateBoard()
{
 
    static int index = 0;
	int x = 32;
	int y = 32;
	  for(int iter1(0); iter1<nRow; iter1++)
	    {
		    index++;
	    	 for(int iter2(0); iter2<nCol; iter2++)
	    	 {
 
	              Tile *temp = new Tile(x ,y,board[iter1][iter2],index);
	              ::tile_set.push_back(temp);
	              if(x >=(width -48*2))
	              {
	            	  x = 32;
	            	  if(y <= width)
	            	       y +=45;
	            	  else if(y >= height )
	            	  {
	            		  cout <<"Sorry \n";
	            		  break;
	            	  }
	              }
	              else
	              {
 
	            	  x +=48;
	              }
 
 
	    	 cout <<"x : "<< x <<" Y :" << y <<endl;
	    	 }
	    	 cout <<"-------------------------------------------------------------------"<<endl;
	    }
 
}
 
void DrawBoard()
{
  for(unsigned int f = 0; f < tile_set.size(); f++)
  {
	SDL_Rect rect ={tile_set[f]->x,tile_set[f]->y,block_size, block_height };
	SDL_RenderCopy(render, texture_list[color_name[tile_set[f]->color]],NULL,&rect );
	SDL_RenderCopy(render, texture_list["cursor"],NULL,&cursor_pos );
  }
}
 
 
bool check_collision( SDL_Rect A, SDL_Rect B )
{
    //The sides of the rectangles
    int leftA, leftB;
    int rightA, rightB;
    int topA, topB;
    int bottomA, bottomB;
 
    //Calculate the sides of rect A
    leftA = A.x;
    rightA = A.x + A.w;
    topA = A.y;
    bottomA = A.y + A.h;
 
    //Calculate the sides of rect B
    leftB = B.x;
    rightB = B.x + B.w;
    topB = B.y;
    bottomB = B.y + B.h;
    //If any of the sides from A are outside of B
        if( bottomA <= topB )
        {
            return false;
        }
 
        if( topA >= bottomB )
        {
            return false;
        }
 
        if( rightA <= leftB )
        {
            return false;
        }
 
        if( leftA >= rightB )
        {
            return false;
        }
 
        //If none of the sides from A are outside B
        return true;
}
 
void SwapVectorValue(vector<Tile *>&ref,int index1, int index2)
{
  /* Tile *temp  = NULL;
   temp->x     = ref[index1]->x;
   temp->y     = ref[index1]->y;
   temp->color = ref[index1]->color;
   temp->index = ref[index1]->index;
 
   ref[index1]->x     = ref[index2]->x;
   ref[index1]->y     = ref[index2]->y;
   ref[index1]->color = ref[index2]->color;
   ref[index1]->index = ref[index2]->index;
 
   ref[index2]->x         = temp->x;
   ref[index2]->y         = temp->y;
   ref[index2]->color     = temp->color;
   ref[index2]->index     = temp->index;
 
	Tile *temp  = ref[index1];
 
	ref[index1] = ref[index2];
	//ref[index1]->color = temp->color;
	ref[index2] = temp;
*/
 
  CopiarTile(ref, index1,index2);
 
}
 
int isCollide()
{
    for(unsigned int g=0; g < tile_set.size();g++)
       {
			  if(check_collision( cursor_pos, tile_set[g]->getRect()))
			  {
				  cout <<"posicion "<< tile_set[g]->x<<" type "<<tile_set[g]->color<<endl;
				  return tile_set[g]->index;
			  }
       }
 cout <<"-9999"<<endl;
 return -9999;
}
 
void CopiarTile(vector<Tile*> &tile, int index1,int index2)
{
	cout <<"preparando para copiar "<<endl;
    cout <<"     x1 : " <<tile[index1]->x<<endl;
    cout <<"     x1 : " <<tile[index1]->y<<endl;
    cout <<"     x1 : " <<tile[index1]->color<<endl;
    cout <<"     x1 : " <<tile[index1]->index<<endl;
    cout <<"---------------------------------------------------------------------------------------\n";
    cout <<"     x2 : " <<tile[index2]->x<<endl;
    cout <<"     x2 : " <<tile[index2]->y<<endl;
    cout <<"     x2 : " <<tile[index2]->color<<endl;
    cout <<"     x2 : " <<tile[index2]->index<<endl;
 
 
	Tile *temp1 = tile[index2];
	Tile *temp2 = tile[index1];
 
 
	cout <<" copiar "<<endl;
    cout <<"     x : " <<temp1->x<<endl;
    cout <<"     y : " <<temp1->y<<endl;
    cout <<" color : " <<temp1->color<<endl;
    cout <<"----------------------------------------------------------------------------\n";
    cout <<"copiar "<<endl;
    cout <<"     x2 : " <<temp2->x<<endl;
    cout <<"     y2 : " <<temp2->y<<endl;
    cout <<" color2 : " <<temp2->color<<endl;
    cout <<"----------------------------------------------------------------------------\n";
    tile[index1]=temp1;
    tile[index2]=temp2;
 
}
 

hay esta too lo que he hecho espero que puedna ayudarme y esto lo ayude a ustedes tambien

Un saludo a todos !!

tengo una duda , yo quiero intercambiar valores dentro de un vector , pero cada vez que accedo a algun elemento usando un objeto temporal recibo un error , vi la funcion std::swap pero ella intercambia entre dos vectores y yo solo tengo uno estoy pensando probar con algun iterador pero me gustaria saber su opinion.

abajo dejo el codigo aunque es algo sencillo

 
void SwapVectorValue(vector<Tile *>&ref,int index1, int index2)
{
   Tile *temp  = NULL;
   temp->x     = ref[index1]->x;
   temp->y     = ref[index1]->y;
   temp->color = ref[index1]->color;
   temp->index = ref[index1]->index;
 
   ref[index1]->x     = ref[index2]->x;
   ref[index1]->y     = ref[index2]->y;
   ref[index1]->color = ref[index2]->color;
   ref[index1]->index = ref[index2]->index;
 
   ref[index2]->x         = temp->x;
   ref[index2]->y         = temp->y;
   ref[index2]->color     = temp->color;
   ref[index2]->index     = temp->index;
 
}
 
 

gracias por su pronta respuesta...!!

ya ese post lo vi... pero cuando de correr una compilacion que es exitosa la aplicacion explota y no hay errores visible , por eso pienso que es algo en el linkeo de la app.


redirigi la salida del la app msys >> ahora tengo  lo siguiente

g++ -I/usr/local/include -I/usr/local/include/FL/images -mwindows -DWIN32 -DUSE_OPENGL32 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o 'main' 'main.cpp' -mwindows /usr/local/lib/libfltk.a -lole32 -luuid -lcomctl32

ahora como podria usar ese conmando en windows suponiendo que tengo los datos en c:/fltk . por favor..

saludos  a todos !!


tengo una duda tengo un proyecto que usa fltk pero no se como hacer que se compile en windows usando mingw , he intentado usar fltk-config pero no lo reconoce me gustaria saber si existe otra forma estoy usando codeblocks o eclipse para ese proyeto.