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

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

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

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

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

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

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

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

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

#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();
  }
}