20/01/2013, 19:41
|
| | | Fecha de Ingreso: enero-2013
Mensajes: 8
Antigüedad: 11 años, 4 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;
}
|