Ver Mensaje Individual
  #1 (permalink)  
Antiguo 20/01/2013, 19:41
rucal
 
Fecha de Ingreso: enero-2013
Mensajes: 8
Antigüedad: 11 años, 9 meses
Puntos: 0
violacion de segmento complicado

Antes que nada pongo el codigo. aunque lo voy a poner casi todo, quizas no sea necesario tanto para ayudarme con mi problema.

imagen.h
Código:
#ifndef IMAGEN_H_
#define IMAGEN_H_

#include <iostream>
#include <cassert>
#include "imagenES.h"

template <class T>
class Imagen{
  
  T** pixeles; ///< Vector de tipo T que almacena los píxeles de una imagen.
  int filas; ///< Número de filas de la imagen.
  int col; ///< Número de columnas de la imagen.

  void Copiar(const Imagen<T> &orig, Imagen<T> &dest);
  void Borrar(Imagen<T> &dest);
  
public:
  Imagen() { filas=col=0;pixeles=0;}
  Imagen(int f, int c);
  Imagen(int f, int c, T *pixeles);
  void getVector(T* &vector);
  Imagen(const Imagen<T> &img);
  ~Imagen();
  Imagen<T> & operator=(const Imagen<T> &img);
  int num_filas() const {return filas; };
  int num_columnas() const {return col; };
  T & operator()(int fila, int col){ return pixeles[fila][col]; }
  const T & operator()(int fila, int col) const { return pixeles[fila][col]; }
  
  
  
  /*************************************************************/
  /*                   CLASE ITERATOR_FILA                     */
  /*************************************************************/

  class iterator_fila{
	  T **p;
	  int ncol;
	  
	public:
	  iterator_fila() { p=0; ncol=0; }
	  iterator_fila(const iterator_fila &it): p(it.p) {}
	  ~iterator_fila() {}
	  T* & operator*() const { assert(p!=0); return *p; }
	  bool operator==(const iterator_fila &it){ return p==it.p; }
	  bool operator!=(const iterator_fila &it){ return p!=it.p  ; }
	  iterator_fila& operator=(const iterator_fila& orig) { p=orig.p; ncol=orig.ncol; return *this; }
	  iterator_fila& operator++() { assert(p!=0); p++; return *this; }
	  iterator_fila& operator--() { assert(p!=0); p--; return *this; }
	  
	  
	  
	  /*************************************************************/
	  /*                   CLASE ITERATOR_COLUMNA		       */
	  /*************************************************************/	  
	  
	  class iterator_columna{
		  T *q;
		public:
		  iterator_columna():q(0) {}
		  iterator_columna(const iterator_columna& it): q(it.q) {}
		  ~iterator_columna() {}
		  T & operator*() const { assert(q!=0); return *q; }
		  bool operator==(const iterator_columna &it) { return q==it.q; }
		  bool operator!=(const iterator_columna &it) { return q!=it.q; }
		  iterator_columna& operator=(const iterator_columna &orig) { q=orig.q; return *this; }
		  iterator_columna& operator++() { assert(q!=0); q++; return *this; }
		  iterator_columna& operator--() { assert(q!=0); q--; return *this; }
		  friend class Imagen<T>;
		  friend class Imagen<T>::iterator_fila;
		  
	  }; // FIN iterator_columna
	  iterator_columna begin();
	  iterator_columna end();
	  
	  friend class Imagen<T>;
	  friend class Imagen<T>::iterator_fila::iterator_columna;
	 
  }; // FIN iterator_fila
  
  
  
  /*************************************************************/
  /*                   CLASE CONST_ITERATOR_FILA               */
  /*************************************************************/

  class const_iterator_fila{
	  T **p;
	  int ncol;
	  
	public:
	  const_iterator_fila() { p=0; ncol=0; }
	  const_iterator_fila(const const_iterator_fila &it):p(it.p) {}
	  ~const_iterator_fila() {}
	  const T* & operator*() const { assert(p!=0); return *p; };
	  bool operator==(const const_iterator_fila &it){ return p==it.p; }
	  bool operator!=(const const_iterator_fila &it){ return p!=it.p; }
	  const_iterator_fila& operator=(const const_iterator_fila& orig) { p=orig.p; ncol=orig.ncol; return *this; }
	  const_iterator_fila& operator++() { assert(p!=0); p++; return *this; }
	  const_iterator_fila& operator--() { assert(p!=0); p--; return *this; }
	  
	  
	  
	  /*************************************************************/
	  /*                   CLASE CONST_ITERATOR_COLUMNA	       */
	  /*************************************************************/	  

	  class const_iterator_columna{
		  T *q;
		public:
		  const_iterator_columna():q(0) {}
		  const_iterator_columna(const const_iterator_columna& it):q(it.q) {}
		  ~const_iterator_columna() {}
		  const T & operator*()const { assert(q!=0); return *q; }
		  bool operator==(const const_iterator_columna &it) { return q==it.q; }
		  bool operator!=(const const_iterator_columna &it) { return q!=it.q; }
		  const_iterator_columna& operator=(const const_iterator_columna &orig) { q=orig.q; return *this; }
		  const_iterator_columna& operator++() { assert(q!=0); q++; return *this; }
		  const_iterator_columna& operator--() { assert(q!=0); q--; return *this; }
		  
		  friend class Imagen<T>;
		  friend class Imagen<T>::const_iterator_fila;
		  
	  }; // FIN const_iterator_columna
	  const_iterator_columna begin() const;
	  const_iterator_columna end() const;

	  friend class Imagen<T>;
	  friend class Imagen<T>::const_iterator_fila::const_iterator_columna;	  
  }; // FIN const_iterator_fila
  iterator_fila begin();
  iterator_fila end();
  const_iterator_fila begin() const; 
  const_iterator_fila end() const;
    
};

#include "imagen.tpp"
#endif
imagen.tpp
Código:
/*************************************************************/
/*                   IMPLEMENTACIÓN                          */
/*************************************************************/
#include <iostream>
using namespace std;
template <class T>
void Imagen<T>::Copiar(const Imagen<T> &orig, Imagen<T> &dest){

  dest.filas=orig.filas;
  dest.col=orig.col;
  
  dest.pixeles=new T*[dest.filas];
  
  dest.pixeles[0]=new T[dest.filas*dest.col];
  
  for(int i=0;i<dest.filas*dest.col;i++)
    dest.pixeles[0][i]=orig.pixeles[0][i];
  
  for(int i=1;i<dest.filas;i++)
    dest.pixeles[0]=dest.pixeles[i-1]+dest.col;
}

template <class T>
void Imagen<T>::Borrar(Imagen<T> &dest){
  delete[] dest.pixeles[0];
  delete[] dest.pixeles;
  dest.filas=dest.col=0;
  dest.pixeles=0;
}

/*************************************************************/
/*              Funciones asociadas a la clase Imagen        */
/*************************************************************/

template <class T>
Imagen<T>::Imagen(int f, int c){
  
  this->pixeles=new T*[f];
  
  this->pixeles[0]=new T[f*c];
  
  for(int i=1;i<f;i++)
    pixeles[i]=pixeles[i-1]+c;
  
  filas=f;
  col=c;
  
}

template <class T>
 Imagen<T>::Imagen(int f, int c,T *pixeles){
   this->filas=f;
   this->col=c;
   this->pixeles=new T*[f];
   this->pixeles[0]=new T[f*c];
   
   for(int i=0;i<f*c;i++)
     this->pixeles[0][i]=pixeles[i];
   
   for(int i=1;i<f;i++)
     this->pixeles[i]=this->pixeles[i-1]+c;
   
 }

template <class T>
void Imagen<T>::getVector(T* &vector) {
  vector=new T[filas*col];
  for(int i=0;i<filas*col;i++)
    vector[i]=pixeles[0][i];


template <class T>
Imagen<T>::Imagen(const Imagen<T> &img){
  
  Copiar(img,*this);
  
}

template <class T>
Imagen<T>::~Imagen(){
  Borrar(*this);
}

//OPERATOR IGUAL CLASE IMAGEN
template <class T>
Imagen<T> & Imagen<T>::operator=(const Imagen<T> &img){
  if(this!=&img){
     Borrar(*this);
     Copiar(img,*this);
  }
  
  return *this;

}

/*************************************************************/
/*              BEGIN Y END                                  */
/*************************************************************/

template <class T>
typename Imagen<T>::iterator_fila::iterator_columna Imagen<T>::iterator_fila::begin(){
  
  typename Imagen<T>::iterator_fila::iterator_columna it;
  
  it.q=*p;
  return it;
  
}

template <class T>
typename Imagen<T>::iterator_fila::iterator_columna Imagen<T>::iterator_fila::end(){
  
  typename Imagen<T>::iterator_fila::iterator_columna it;
  
  it.q=(*p+ncol);

  return it;
  
}
  
template <class T>
typename Imagen<T>::iterator_fila Imagen<T>::begin(){
    

  typename Imagen<T>::iterator_fila it;
  
  it.p=pixeles;
  it.ncol=col;
  return it;
  
}

template <class T>
typename Imagen<T>::iterator_fila Imagen<T>::end(){
  
  typename Imagen<T>::iterator_fila it;
  
  it.p=(&pixeles[0]+filas);

  return it;
  
}

template <class T>
typename Imagen<T>::const_iterator_fila::const_iterator_columna Imagen<T>::const_iterator_fila::begin() const{
  
  typename Imagen<T>::const_iterator_fila::const_iterator_columna it;
  
  it.q=*p;
  return it;
  
}

template <class T>
typename Imagen<T>::const_iterator_fila::const_iterator_columna Imagen<T>::const_iterator_fila::end() const{
  
  typename Imagen<T>::const_iterator_fila::const_iterator_columna it;
  
  it.q=(*p+ncol);

  return it;
  
}
  
template <class T>
typename Imagen<T>::const_iterator_fila Imagen<T>::begin() const{
    

  typename Imagen<T>::const_iterator_fila it;
  
  it.p=pixeles;
  it.ncol=col;
  return it;
  
}

template <class T>
typename Imagen<T>::const_iterator_fila Imagen<T>::end() const{
  
  typename Imagen<T>::const_iterator_fila it;
  
  it.p=(&pixeles[0]+filas);

  return it;
  
}