Temas

Buenos días,

Primeras aclaraciones:
  No vengo a preguntar cómo hacer un troyano, ni a pedir un source code de uno de ellos, ni a preguntar como funciona un troyano ya desarrollado.

Segundas aclaraciones. Conocimientos:
  Avanzados en programación en distintos lenguajes. Utilizaré para este proyecto C++ y ASM.
  Básicos de criptografía (Diferenciación entre distintos tipos de criptografía, como por ejemplo simetrica y asimetrica, y conocimientos básicos del funcionamiento de éstos).
  En seguridad, tanto de redes como de aplicaciones (He realizado varias pruebas de concepto. Considero básicas para éste proyecto: Reversing, DLL Injection, API Hooking, Social Engineering - Phising, MiTM, ...)
  Y seguro que alguna cosa más me dejo que necesite para llevar a cabo este proyecto.

Terceras y últimas aclaraciones:
  El proyecto del que voy a haceros unas preguntas trata del desarrollo de un troyano medianamente avanzado. Incluiría rootkit, sistemas de propagación, sistemas de espionaje y sistemas de control. Algo que si en un futuro se pusiera en marcha y tuviera éxito, se pudiera considerar algo como una botnet.

Una vez hechas éstas tan necesarias aclaraciones, voy al grano;
  Quiero empezar a desarrollar malware por cuenta propia (inicialmente para sistemas windows), y tengo una serie de dudas al respecto:
    1. Localización del malware: ¿Cual es la mejor localización de un malware dentro de un sistema? ¿Sistema de arranque, drivers, archivos temporales, ...? ¿Porque?
    2. Antivirus: ¿Cómo un antivirus identifica un proceso malicioso? ¿Que reglas siguen los antivirus más modernos?
    3. ¿Que "estructura o diseño" consideráis la mejor para este tipo de malware? ¿Porque?

He de decir que me he estado mirando las preguntas más frecuentes y sí que es verdad que algunas responderían a mis dudas, pero los posts o se han eliminado o están incompletos y no me dan la información que necesito.

Muchas gracias por leeros el tostón y espero que alguien pueda responderme
Un saludo!

Buenas noches,
estoy buscando información acerca de los inputs, outputs y como recorre el grafo (por nodos, aristas o ambos) de los algoritmos de búsqueda de comunidades Girvan-Newman, Clique Percolation y Louvain, pero no encuentro nada sobre ello, la información es muy difusa y lo máximo a lo que accedo es a proyectos de decenas de clases que no se ni por donde empezar a mirar.
¿Alguien podría echarme una mano con esto?

Muchas gracias.

Buenas noches,
estoy haciendo un programa para aprovechar la característica del EOF para ocultar archivos dentro de otros, pero tengo un problema un tanto extraño al escribir en el archivo "objetivo". Cuando hago una pequeña modificación en uno de los while del programa, deja de escribirme el archivo completo y escribe solo unos pocos bytes. Concretando:

Código fuente (funcionando)
http://pastebin.com/ygNq6K1t

La modificación que estoy realizando es substituir el código del while de la línea 31 por el siguiente:

Código (c) [Seleccionar] Expandir


  while(read(src_fc, buffer, strlen(buffer)) > 0)
  {
    if(write(obj_fd, buffer, strlen(buffer)) < 0)
    {
      strcpy (buffer, "Error in write.\n");
      write (1, buffer, strlen (buffer));
    }
  }


Como se puede ver, la única diferencia es que elimino el mensaje de "512b.", pero aun asi la aplicación deja de leer/escribir a los pocos bytes copiados.

¿Alguna idea?

¡Muchas gracias!

Buenas, estoy intentando implementar QuickSort para ordenar un vector cualquiera, pero estoy teniendo problemas.
La función ordena correctamente, pero una vez el vector está ordenado mi función recursiva sigue ejecutandose en un bucle infinito, y no logro encontrar el error.
El código del QuickSort es el siguiente:

Código (cpp) [Seleccionar] Expandir

int splitArray(vector<int>&v, int l, int r)
{
 int pivot = r;
 int leftInd = l;
 while(leftInd < pivot)
 {
   if(v[leftInd] > v[pivot])
   {
     swap(v, leftInd, pivot-1);
     swap(v, pivot-1, pivot);
     if(pivot>0) --pivot;
   }
   else ++leftInd;
 }
 return pivot;
}

void quickSort(vector<int>& v, int l, int r)
{
 if(r > l)
 {
   int pivot = splitArray(v, l, r);
   quickSort(v, l, pivot);
   quickSort(v, pivot+1, r);
 }
}
NOTA: las variables "l" y "r" significan "left" y "right". La función swap() es trivial, intercambia las dos variables que se le pasan por parametros (el primer parámetro es el vector, y los dos siguientes las posiciones de los valores a intercambiar).

Es muy probable que la implementación tampoco sea la más eficiente, ya que intenté entender un código de quicksort ya hecho y no lograba verlo, por lo que decidí implementarlo yo por mi cuenta. Acepto críticas y consejos

Muchas gracias.

Solucionado:

Código (cpp) [Seleccionar] Expandir

void quickSort(vector<int>& v, int l, int r)
{
  if(r > l)
  {
    int pivot = splitArray(v, l, r);
    quickSort(v, l, pivot-1);  //AQUÍ EL ERROR, NO LE RESTABA 1 A PIVOT
    quickSort(v, pivot+1, r);
  }
}

Saludos

Estoy desarrollando un juego y estoy pensando en cómo estructurar el servidor para implementar el multijugador. El juego es un estilo arcade de partidas cortas, donde un jugador puede crear una partida (alojada en el servidor de momento) y el resto de jugadores unirse a ella.
Tengo pensado crear una clase Servidor, desde la que se gestionarán las partidas mediante multithreading. Es decir, existirá una clase Partida que se ejecutará en un nuevo thread, y desde la cual se gestionarán también las conexiones de sus distintos jugadores mediante nuevos threads (un thread por jugador, que contendrá un socket a su vez).
Podríamos decir entonces, que la estructura del servidor que estoy describiendo sería algo como:

Código [Seleccionar] Expandir


                      -> Jugador > Socket
         -> Partida  -> Jugador > Socket
                     -> Jugador > Socket

                     -> Jugador > Socket
Servidor  -> Partida  -> Jugador > Socket
                     -> Jugador > Socket

                     -> Jugador > Socket
         -> Partida  -> Jugador > Socket
                     -> Jugador > Socket

Donde cada objeto perteneciente al esquema sería un nuevo thread (excepto los sockets, que pertenecen al objeto Jugador).

La verdad, no creo que esta sea la mejor forma ya que en caso de que haya varias partidas llenas la cantidad de threads sería altisima, por eso me gustaría que me dierais opinión y consejo sobre esto.

Gracias.

[TicTacToe]

Buenas, estoy aprendiendo java y me he propuesto crear un TicTacToe como ejercicio de entrenamiento.
He desarrollado dos clases, la clase Jugador y la clase Tablero. El esquema que tengo pensado es crear una instancia de Tablero y posteriormente pasar un puntero a cada Jugador para que puedan operar directamente con el, pero no se como hacer esto.
Les pongo un ejemplo:

Código (java) [Seleccionar] Expandir

public class Tablero
{
...
}

public class Jugador
{
  private Tablero tablero;
  Jugador(Tablero tablero)
  {
    this.tablero = tablero;
  }
}

Entonces, si hiciera:

Código (java) [Seleccionar] Expandir

Tablero tab = new Tablero();
Jugador jug = new Jugador(tab);

El objeto jug contendrá una copia de tab, o un puntero a tab?

Buenos dias

Estoy programando un crackme sencillo para practicar ingenieria inversa, pero no consigo que se me compile correctamente en 32bits (Estoy usando un Linux 64bits). Compilo mediante g++ y usando la opción -m32 de la siguiente manera:

Código [Seleccionar] Expandir


g++ -c -m32 crackme1.cpp
g++ -o crackme1.exe -m32 crackme1.o


El programa compila perfectamente y puedo ejecutarlo desde linux, pero cuando intento ejecutarlo desde un Windows 7 64bits o abrirlo con OllyDBG me dice que no es una aplicación de 32bits, sinó de 64. En Windows me sale un error también del estilo.

Ya he compilado antes en 32bits desde el mismo ordenador y sistema operativo y no he tenido problemas, así que no creo que sea tema de librerias o algo parecido :S

Os adjunto el código por si alguien se anima a intentar compilarlo bajo un sistema de 32 bits y a ver si alguien se le ocurre que puede estar pasando.

Código del crackme:
http://pastebin.com/hPSUHR4u

Gracias.

Buenas noches.
Estoy desarrollando una DLL para hookear una serie de procesos de una aplicación conectada a un servidor (es un cliente en lo que seria una conexión cliente-servidor). Pues bien, el hecho es que estoy controlando los paquetes que entran y salen mediante esta DLL y he implementado una pequeña función que envía paquetes legítimos a través del propio cliente.
El problema que tengo es que hay una serie de paquetes que necesitan una cierta diferencia de tiempo entre ellos, pero no puedo congelar la aplicación mientras espero ese tiempo (Por lo tanto, Sleep() y cualquier bucle que congele la aplicación quedan descartados), por lo que me estoy planteando utilizar multithreading, pero antes quería preguntaros si se os ocurre alguna otra forma de hacer esto. ¿Quizás una cola de paquetes y alguna manera de controlar cuándo se mandan a la función SendPacket?

Gracias

He desarrollado una clase Pila y una Clase cola para estudiar de cara a la universidad y se me ha ocurrido publicarla aquí, ya que estoy viendo publicaciones en las que se hacen preguntas sobre la implementación de estas clases y podrían ayudar a más de uno. Si alguien encuentra algún error que lo comente, por favor.

Aquí los archivos:

Stack.h

Código (cpp) [Seleccionar] Expandir

#include <cstddef>

template <class T>
class Stack
{
  private:
    struct Node
    {
      Node* nextNode;
      T data;
    };
   
    Node* topNode = NULL;
    int dataSize = 0;
   
    static Node* copyNode(Node* node)
    {
      Node* newNode = NULL;
      if (node)
      {
newNode = new Node;
newNode->data = node->data;
newNode->nextNode = copy(node->nextNode);
      }
      return newNode;
    }
    static void deleteNode(Node* node)
    {
      if (node)
      {
deleteNode(node->nextNode);
delete node;
      }
    }
   
  public:
    Stack();
    Stack(const Stack& original);
    ~Stack();

    T top() const;
    bool empty() const;
    int size() const;
   
    void push(const T& data);
    void pop();
    void clear();
   
    Stack& operator =(const Stack& original);
};

template <class T>
Stack<T>::Stack() {}

template <class T>
Stack<T>::Stack(const Stack &original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    topNode = copy(original.topNode);
  }
}

template <class T>
Stack<T>::~Stack()
{
  deleteNode(this->topNode);
}

template <class T>
Stack<T>& Stack<T>::operator =(const Stack& original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    deleteNode(topNode);
    topNode = copyNode(original.topNode);
  }
  return *this;
}

template <class T>
T Stack<T>::top() const
{
  return topNode->data;
}

template <class T>
void Stack<T>::push(const T& data)
{
  Node* newTop = new Node;
  newTop->data = data;
  newTop->nextNode = topNode;
  topNode = newTop;
 
  dataSize = dataSize + 1;
}

template <class T>
void Stack<T>::pop()
{ 
  Node* auxNode = topNode;
  topNode = topNode->nextNode;
  delete auxNode;
 
  dataSize = dataSize - 1;
}

template <class T>
bool Stack<T>::empty() const
{
  return (topNode == NULL);
}

template <class T>
int Stack<T>::size() const
{
  return dataSize;
}

template <class T>
void Stack<T>::clear()
{
  deleteNode(topNode);
  topNode = NULL;
  dataSize = 0;
}

Queue.h

Código (cpp) [Seleccionar] Expandir

#include <cstddef>

template <class T>
class Queue
{
  private:
    struct Node
    {
      T data;
      Node* prevNode;
    };
   
    int dataSize;
    Node* frontNode;
    Node* lastNode;
   
    static Node* copyNode(Node* node, Node* last)
    {
      Node* newNode = NULL;
      if(node)
      {
newNode = new Node;
newNode->data = node->data;
newNode->prevNode = copyNode(node->prevNode);
if (newNode->nextNode == NULL) last = newNode;
      }
      return newNode;
    }
   
    static void deleteNode(Node* node)
    {
      if(node)
      {
deleteNode(node->prevNode);
delete node;
      }
    }

  public:
    Queue();
    Queue(const Queue& original);
    ~Queue();
   
    T front() const;
    bool empty() const;
    int size() const;
   
    void push(const T &data);
    void pop();
    void clear();
   
    Queue& operator =(const Queue& original);
};

template <class T>
Queue<T>::Queue()
{
  dataSize = 0;
  frontNode = NULL;
  lastNode = NULL;
}

template <class T>
Queue<T>::Queue(const Queue& original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    frontNode = copyNode(original.frontNode);
  }
}

template <class T>
Queue<T>::~Queue()
{
  deleteNode(frontNode);
}

template <class T>
T Queue<T>::front() const
{
  return frontNode->data;
}

template <class T>
bool Queue<T>::empty() const
{
  return (frontNode == NULL);
}

template <class T>
int Queue<T>::size() const
{
  return dataSize;
}

template <class T>
void Queue<T>::push(const T &data)
{
  Node* newNode = new Node;
  newNode->data = data;
  newNode->prevNode = NULL;
  if (!frontNode) frontNode = newNode;
  else lastNode->prevNode = newNode;
  lastNode = newNode;
 
  dataSize = dataSize + 1;
}

template <class T>
void Queue<T>::pop()
{
  Node* aux = frontNode;
  frontNode = frontNode->prevNode;
  delete aux;
 
  dataSize = dataSize - 1;
}

template <class T>
void Queue<T>::clear()
{
  deleteNode(frontNode);
  frontNode = NULL;
  lastNode = NULL;
  dataSize = 0;
}

template <class T>
Queue<T>& Queue<T>::operator =(const Queue& original)
{
  if (this != &original)
  {
    dataSize = original.dataSize;
    deleteNode(frontNode);
    frontNode = copyNode(original.frontNode);
  }
  return *this;
}

Saludos.

Estoy desarrollando una clase Matriz, en la que le he incluido varias sobrecargas de operadores para poder trabajar con estas matrices de una manera más cómoda. El problema viene dado cuando entra en juego el operador de asignación, cuando usa la operación delete para liberar la memoria de la matriz y crear una copia del parámetro, que me da el siguiente error, además de un mapeado de memoria:

Código [Seleccionar] Expandir

*** glibc detected *** ./test.exe: free(): invalid pointer: 0x0000000000401662 ***

Os adjunto el código de la clase y el código de test.exe:

Matriz.h

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <vector>

using namespace std;

class Matriz {

private:
 
 int nfilas;
 int ncolumnas;
 int **matr;

public:

 //Constructoras
 Matriz();
 Matriz(int filas, int columnas);
 
 //Destructora
 ~Matriz();
 
 //Consultoras
 int filas() const;
 int columnas() const;
 int consultar(int fila, int columna) const;
 
 //Modificadora
 void modificar(int fila, int columna, int x);
 
 //Entrada / Salida
 void leer();
 void escribir();
 
 //Operadores
 Matriz operator +(const Matriz &b) const;
 Matriz operator -(const Matriz &b) const;
 Matriz operator *(const Matriz &b) const;
 Matriz operator =(const Matriz &b);
 
 bool operator ==(const Matriz &mat) const;
 bool operator !=(const Matriz &mat) const;
};

Matriz::Matriz() {}

Matriz::Matriz(int filas, int columnas)
{
 this->nfilas = filas;
 this->ncolumnas = columnas;
 
 matr = new int* [filas];
 for (int i = 0; i < filas; ++i)
 {
   matr[i] = new int [columnas];
 }
}

Matriz::~Matriz()
{
 delete matr;
}

int Matriz::filas() const
{
 return nfilas;
}

int Matriz::columnas() const
{
 return ncolumnas;
}

int Matriz::consultar(int fila, int columna) const
{
 return matr[fila][columna];
}

void Matriz::modificar(int fila, int columna, int x)
{
 matr[fila][columna] = x;
}

void Matriz::leer()
{
 for (int i = 0; i < nfilas; ++i)
   for (int j = 0; j < ncolumnas; ++j) cin >> matr[i][j];
}

void Matriz::escribir()
{
 for (int i = 0; i < nfilas; ++i)
 {
   for (int j = 0; j < ncolumnas; ++j) cout << matr[i][j] << " ";
   cout << endl;
 }
}

Matriz Matriz::operator +(const Matriz &b) const
{
 int filas = this->nfilas;
 int columnas = this->ncolumnas;
 
 Matriz res(filas, columnas);
 
 for (int i = 0; i < filas; ++i)
   for (int j = 0; j < columnas; ++j)
     res.matr[i][j] = this->matr[i][j] + b.matr[i][j];
   
 return res;
}

Matriz Matriz::operator -(const Matriz &b) const
{
 int filas = this->nfilas;
 int columnas = this->ncolumnas;
 
 Matriz res(filas, columnas);
 
 for (int i = 0; i < filas; ++i)
   for (int j = 0; j < columnas; ++j)
     res.matr[i][j] = this->matr[i][j] - b.matr[i][j];
   
 return res;
}

Matriz Matriz::operator *(const Matriz &b) const
{
 if (this->ncolumnas == b.nfilas)
 {
   int pos = this->ncolumnas;
   int filas = this->nfilas;
   int columnas = b.ncolumnas;
   
   Matriz res(filas, columnas);
   for (int i = 0; i < filas; ++i)
   {
     for (int j = 0; j < columnas; ++j)
     {
int value = 0;
for (int k = 0; k < pos; ++k) value += this->matr[i][k] * b.matr[k][j];
res.matr[i][j] = value;
     }
   };
   return res;
 }
}

Matriz Matriz::operator =(const Matriz &mat)
{
 if (this != &mat)
 {
   cout << "flag1" << endl;
   delete this->matr;
   cout << "flag2" << endl;
   if (mat.matr)
   {
     this->nfilas = mat.nfilas;
     this->ncolumnas = mat.ncolumnas;
     
     matr = new int* [nfilas];
     for (int i = 0; i < nfilas; ++i)
     {
matr[i] = new int [ncolumnas];
     }
     
     for (int i = 0; i < nfilas; ++i)
     {
for (int j = 0; j < ncolumnas; ++j)
{
 matr[i][j] = mat.matr[i][j];
}
     }
   }
   else this->matr = NULL;
 }
 return *this;
}

bool Matriz::operator ==(const Matriz &mat) const
{
 for (int i = 0; i < nfilas; ++i)
   for (int j = 0; j < ncolumnas; ++j)
     if (this->matr[i][j] != mat.matr[i][j]) return false;
 
 return true;
}

bool Matriz::operator !=(const Matriz &mat) const
{
 for (int i = 0; i < nfilas; ++i)
   for (int j = 0; j < ncolumnas; ++j)
     if (this->matr[i][j] != mat.matr[i][j]) return true;
 
 return false;
}


Código (cpp) [Seleccionar] Expandir


#include "Matriz.h"

int main()
{
 int f1, c1, f2, c2;

 cout << "Introduce el tamaño de la primera matriz:" << endl;
 cin >> f1 >> c1;
 Matriz mat1(f1, c1);
 cout << "Introduce los valores de la matriz:" << endl;
 mat1.leer();
 
 cout << "Introduce el tamaño de la segunda matriz:" << endl;
 cin >> f2 >> c2;
 Matriz mat2(f2, c2);
 cout << "Introduce los valores de la matriz:" << endl;
 mat2.leer();

 
 if (c1 == f2)
 {
   Matriz res;
   res = mat1 * mat2;

   res.escribir();
 }
}


He probado varias cosas, como cambiar delete por delete[], o intentar eliminar los vectores individualmente, pero ninguna ha dado resultado. Algo debo estar haciendo mal, pero no encuentro el error. Si le pudierais echar un ojo me haríais un favor.

Muchas gracias.

Estoy desarrollando un juego en el que nuestro personaje se encarga de pintar una superficie (una matriz a nivel de código). El problema es que quiero implementar que una vez ha pintado el relieve de una figura cerrada, se pinte también el interior.

El funcionamiento del juego es como el de cualquier tile-based game: El mapa es una matriz de enteros. Cada posición contiene un entero que determina que textura tendrá esa casilla y si el personaje puede pasar por encima de ella. Por lo tanto, podemos definir que las casillas se encuentran inicialmente en 0 (excepto los muros, que diremos que son -1), y que cuando pasan por encima, cambiamos su valor a 1.

Entonces, el problema a nivel de código es identificar en una matriz una figura cerrada hecha a base de 1s. Había pensado en un BFS, pero no estoy seguro de que sea la mejor opción. ¿Se os ocurre algún otro método más eficiente para hacer esto?

Saludos y gracias.

[NOTA]

Dadas dos funciones, necesito pasar un puntero por referencia de una función a la otra para obtener los datos de una lista de strings (las dos funciones están dentro de la misma clase).
El problema viene dado a que desde un objeto de esa clase, necesito acceder a datos privados de otro objeto del mismo tipo (una lista de strings). Entonces, la solución más eficiente que se me ha ocurrido es crear un puntero de tipo vector<string> vect, pasarlo por referencia a la otra función, y en esa hacer vect = new vector<string> (N), donde N es el tamaño de la lista de la que quiero obtener sus elementos, pero me da errores de compilación y no consigo resolverlos.

Os adjunto el código de las dos funciones implicadas y el error recibido al compilar (compilo en Linux con G++):

NOTA: La primera función empieza en la línea 33, y la segunda en la línea 71, por lo que los errores saltan en las líneas marcadas con el comentario ERROR EN ESTA LÍNEA.

Código (cpp) [Seleccionar] Expandir


#include <vector>
#include <list>

list<string> lista; //Esto está declarado en la parte privada de la clase

void Objeto::fusion_objeto(const Objeto &rev)
{
 //Declaro puntero
 vector<string> *s = NULL;
 rev.func_aux(s);
 int n = s->size();
 for (int i = 0; i < n; ++i) lista.insert(lista.begin(), s[i]); //ERROR EN ESTA LÍNEA
 delete s;
}

void Objeto::func_aux(vector<string>* &s)
{
 int N = lista.size();
 s = new vector<string> (N);
 list<string>::iterator it = lista.begin();
 for (int i = 0; i < N; ++i)
 {
   s[i] = *it; //ERROR EN ESTA LÍNEA
   ++it;
 }
}


Error de la primera función:

Código [Seleccionar] Expandir


Objeto.cpp: In member function 'void Objeto::fusion_objeto(const Objeto&)':
Objeto.cpp:39:69: error: no matching function for call to 'std::list<std::basic_string<char> >::insert(std::list<std::basic_string<char> >::iterator, std::vector<std::basic_string<char> >&)'
Objeto.cpp:39:69: note: candidates are:
In file included from /usr/include/c++/4.7/list:65:0,
                from Objeto.hpp:8,
                from Objeto.cpp:1:
/usr/include/c++/4.7/bits/list.tcc:99:5: note: std::list<_Tp, _Alloc>::iterator std::list<_Tp, _Alloc>::insert(std::list<_Tp, _Alloc>::iterator, const value_type&) [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<std::basic_string<char> >; std::list<_Tp, _Alloc>::value_type = std::basic_string<char>]
/usr/include/c++/4.7/bits/list.tcc:99:5: note:   no known conversion for argument 2 from 'std::vector<std::basic_string<char> >' to 'const value_type& {aka const std::basic_string<char>&}'
In file included from /usr/include/c++/4.7/list:64:0,
                from Objeto.hpp:8,
                from Objeto.cpp:1:
/usr/include/c++/4.7/bits/stl_list.h:1104:7: note: void std::list<_Tp, _Alloc>::insert(std::list<_Tp, _Alloc>::iterator, std::list<_Tp, _Alloc>::size_type, const value_type&) [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >; std::list<_Tp, _Alloc>::iterator = std::_List_iterator<std::basic_string<char> >; std::list<_Tp, _Alloc>::size_type = long unsigned int; std::list<_Tp, _Alloc>::value_type = std::basic_string<char>]
/usr/include/c++/4.7/bits/stl_list.h:1104:7: note:   candidate expects 3 arguments, 2 provided
/usr/include/c++/4.7/bits/stl_list.h:1125:9: note: template<class _InputIterator> void std::list::insert(std::list<_Tp, _Alloc>::iterator, _InputIterator, _InputIterator) [with _InputIterator = _InputIterator; _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >]
/usr/include/c++/4.7/bits/stl_list.h:1125:9: note:   template argument deduction/substitution failed:
Objeto.cpp:39:69: note:   candidate expects 3 arguments, 2 provided



Error de la segunda función:

Código [Seleccionar] Expandir


Objeto.cpp: In member function 'void Objeto::func_aux(std::vector<std::basic_string<char> >*&)':
Objeto.cpp:78:13: error: no match for 'operator=' in '*(s + ((sizetype)(((long unsigned int)i) * 24ul))) = it.std::_List_iterator<_Tp>::operator*<std::basic_string<char> >()'
Objeto.cpp:78:13: note: candidate is:
In file included from /usr/include/c++/4.7/vector:70:0,
                from Objeto.hpp:9,
                from Objeto.cpp:1:
/usr/include/c++/4.7/bits/vector.tcc:161:5: note: std::vector<_Tp, _Alloc>& std::vector<_Tp, _Alloc>::operator=(const std::vector<_Tp, _Alloc>&) [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >]
/usr/include/c++/4.7/bits/vector.tcc:161:5: note:   no known conversion for argument 1 from 'std::basic_string<char>' to 'const std::vector<std::basic_string<char> >&'


Tiene pinta de que acceda mal a las posiciones del vector dinámico. He probado con lo siguiente, pero lógicamente no funciona.

Código [Seleccionar] Expandir

*(s[i])

¿Alguna idea?

Saludos y gracias

[Solucionado:]

Considerando las siguientes implementaciones:

Código (cpp) [Seleccionar] Expandir


vector< list<Objeto> > list_1(N);
vector< list<Revistes>::iterator > list_2(N);


Código (cpp) [Seleccionar] Expandir


struct Conj {
 Objeto obj;
 list<Objeto>::iterator it; //puntero a un objeto contenido en una lista del tipo especificado
}
 
vector< list<Conj> > list_rev(N);


¿Cual creeis que consume menos memoria? Ya que a simple vista guarda los mismos datos, pero lo que me hace dudar es la información de más que puede generar un struct, un vector o una lista enlazada para funcionar correctamente, ya que estas últimas por ejemplo, por cada posición de la lista se guardan dos punteros para referenciar al elemento anterior y al siguiente.

Saludos



Solucionado: La segunda opción consume menos memoria que la primera, ya que por cada lista de más que generemos, aumentamos los punteros totales que utiliza el programa. En canvio, un struct guarda los datos en bloques y no necesita de datos adicionales para funcionar, por lo tanto nos ahorramos los punteros de una lista.

Saludos

Buscando guias sobre el uso de sockets en C++, he encontrado esta libreria que puede ser muy útil, sobre todo si lo que se busca es crear un código sencillo y fácil de entender, algo parecido a lo que ocurre con la clase socket en C#. Aquí teneis la descripción:

Esta es una libreria de clases en C++ bajo licencia GPL que 'mapea' el berkeley sockets C API, y funciona tanto en algunos sistemas unix como en win32. Las características incluidas, aunque no limitadas son: SSL support, IPv6 support, tcp and udp sockets, encrypted tcp, http protocol, altamente configurable el manejo de errores. Las pruebas de Testeo han sido efectuadas en: Linux and Windows 2000, and to some part on Solaris and Mac OS X.

Enlace: http://www.alhem.net/Sockets/index_spanish.html

La propia página web incluye un tutorial y ejemplos de uso de la clase Socket y SocketHandler (ambas incluidas en la libreria), y distintas descargas (entre las que está la documentación de las clases generada por Doxygen). Está disponible en inglés y español, aunque recomiendo la versión inglesa por la mala traducción del sitio.

Saludos

[const]

Buenas. Tengo un pequeño problema con una clase Matriz que estoy desarrollando en C++. Según tengo entendido, cuando un parámetro de una función va a ser constante durante toda la ejecución de esa función, se pasa ese parámetro en forma constante y por referencia. Bien, el problema es que en mi clase matriz, me salta un error de compilación en la copiadora-constructora por el uso del tag const en las tres consultoras de la clase (si lo haces desde fuera la clase, los métodos que hacen saltar el error si que funcionan). El error es el siguiente (compilado con g++):

Código [Seleccionar] Expandir

In file included from multiplicacion_matriz.cpp:1:0:
Matriz.cpp: In copy constructor 'Matriz::Matriz(const Matriz&)':
Matriz.cpp:54:37: error: passing 'const Matriz' as 'this' argument of 'const int Matriz::consultar_filas()' discards qualifiers [-fpermissive]
Matriz.cpp:55:43: error: passing 'const Matriz' as 'this' argument of 'const int Matriz::consultar_columnas()' discards qualifiers [-fpermissive]
Matriz.cpp:68:38: error: passing 'const Matriz' as 'this' argument of 'const int Matriz::consultar(int, int)' discards qualifiers [-fpermissive]
Matriz.cpp: In member function 'void Matriz::sumar(const Matriz&)':
Matriz.cpp:101:72: error: passing 'const Matriz' as 'this' argument of 'const int Matriz::consultar(int, int)' discards qualifiers [-fpermissive]
Matriz.cpp: In member function 'void Matriz::multiplicar(const Matriz&, int)':
Matriz.cpp:111:75: error: passing 'const Matriz' as 'this' argument of 'const int Matriz::consultar(int, int)' discards qualifiers [-fpermissive]


Y el código de la clase en la que salta el error es este:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <vector>

using namespace std;

class Matriz {

private:
 
 int filas;
 int columnas;
 int **matr;

public:

 //Constructora
 Matriz(int filas, int columnas);
 
 //Constructora-copiadora
 Matriz(const Matriz &mat);
 
 //Destructora
 ~Matriz();
 
 //Consultoras
 const int consultar_filas();
 const int consultar_columnas();
 const int consultar(int fila, int columna);
 
 //Modificadora
 void modificar(int fila, int columna, int x);
 void sumar(const Matriz &mat);
 void multiplicar(const Matriz &mat, int pos);
 
 //Entrada / Sortida
 void leer();
 void escribir();
};

Matriz::Matriz(int filas, int columnas)
{
 this->filas = filas;
 this->columnas = columnas;
 
 matr = new int* [filas];
 for (int i = 0; i < filas; ++i)
 {
   matr[i] = new int [columnas];
 }
}

Matriz::Matriz(const Matriz &mat)
{
 this->filas = mat.consultar_filas();
 this->columnas = mat.consultar_columnas();
 
 matr = new int* [filas];
 for (int i = 0; i < filas; ++i)
 {
   matr[i] = new int [columnas];
 }
 
 
 for (int i = 0; i < filas; ++i)
 {
   for (int j = 0; j < columnas; ++j)
   {
     matr[i][j] = mat.consultar(i, j);
   }
 }
}

Matriz::~Matriz()
{
 delete[] matr;
}

const int Matriz::consultar_filas()
{
 return this->filas;
}

const int Matriz::consultar_columnas()
{
 return this->columnas;
}

const int Matriz::consultar(int fila, int columna)
{
 return this->matr[fila][columna];
}

void Matriz::modificar(int fila, int columna, int x)
{
 matr[fila][columna] = x;
}

void Matriz::sumar(const Matriz &mat)
{
 for (int i = 0; i < filas; ++i)
   for (int j = 0; j < columnas; ++j) matr[i][j] += mat.consultar(i, j);
}

void Matriz::multiplicar(const Matriz &mat, int pos)
{
 for (int i = 0; i < filas; ++i)
 {
   for (int j = 0; j < columnas; ++j)
   {
     int res = 0;
     for (int k = 0; k < pos; ++k) res += matr[i][k] * mat.consultar(k, j);
     matr[i][j] = res;
   }
 }
}

void Matriz::leer()
{
 for (int i = 0; i < filas; ++i)
   for (int j = 0; j < columnas; ++j) cin >> matr[i][j];
}

void Matriz::escribir()
{
 for (int i = 0; i < filas; ++i)
 {
   for (int j = 0; j < columnas; ++j) cout << matr[i][j] << " ";
   cout << endl;
 }
}


Si elimino la etiqueta const de las tres funciones que devuelven un error al compilar, el error desaparece, pero me gustaría saber el porque de este error, ya que los métodos que utilizo con el objeto constante no son modificadores, e incluso he probado a hacer los métodos constantes por si acaso, pero ni con esas.

Gracias!



Al final he conseguido averiguar cual era el problema. Si colocas la etiqueta const delante de una función, estás indicando que el resultado de ésta sera de un tipo constante. En cambio, si lo colocas detrás, estás diciendo que la función no modificará ningún parámetro. Por lo tanto, la solución al error es cambiar las etiquetas de sitio y ponerlas detrás de la función. De esta manera le aseguras al compilador que esa función no modificará ningún parámetro.

Saludos

Mientras desarrollaba una pequeña clase Matriz, me ha surgido una duda: ¿Que diferencia hay entre usar una constructora copiadora o igualar dos objetos (ej: mat1 = mat2, siendo mat1 y mat2 objetos de la clase Matriz)?
En este caso, la constructora-copiadora hacía uso de los típicos dos bucles for para recorrer toda la matriz y ir copiandola al parámetro implícito (formato constructora: Matriz(Matriz &mat); ), pero me ha surgido la duda de si era más eficiente igualar dos objetos de tipo matriz y olvidarme de la constructora-copiadora. Por eso, me gustaría saber que ocurre realmente cuando igualas dos objetos del mismo tipo.

Saludos y gracias.