1. CRySoL
  2. Untitled project
  3. PensarEnC++

Commits

David Villa Alises  committed 0995aff

revisando C13

  • Participants
  • Parent commits f4d256e
  • Branches PensarEnC++

Comments (0)

Files changed (1)

File V1-C13.xml

View file
  • Ignore whitespace
 		<function>opertator new()</function> y <function>operatator delete()</function>.
       </para>
 
-<!-- Por aquí me quedé revisando:2011 -->
-
 
     <!--
     The memory allocation system used by new and delete is designed for general-purpose use.
     problems like this.
     -->
       <para>
-	El sistema de asignación de memoria usado por
-	<kw>new</kw> y <kw>delete</kw> es un
-	sistema de propósito general. En situaciones especiales,
-	puede que no funcione como se requiere. Frecuentemente la
-	razón para cambiar el asignador es la eficiencia; puede ser
-	que se necesite crear y destruir tantos objetos de la misma
-	clase que lo haga ineficaz en términos de velocidad: un
-	cuello de botella. En C++ es posible sobrecargar
-	<kw>new</kw> y <kw>delete</kw> para
-	implementar un esquema particular más adecuado que permita
-	manejar situaciones como esta.
+		El sistema de asignación de memoria usado por <kw>new</kw> y <kw>delete</kw> es un
+		sistema de propósito general. En situaciones especiales, puede que no funcione
+		como se requiere. Frecuentemente la razón para cambiar el asignador es la
+		eficiencia; puede que se necesite crear y destruir tantos objetos de la misma
+		clase que lo haga ineficaz en términos de velocidad: un cuello de botella. En C++
+		es posible sobrecargar <kw>new</kw> y <kw>delete</kw> para implementar un esquema
+		particular más adecuado que permita manejar situaciones como ésta.
       </para>
     <!--
     Another issue is heap fragmentation. By allocating objects of different sizes it’s
     ensure this never happens.
     -->
       <para>
-	Otra cuestión es la fragmentación del montículo. Cuando
-	los objetos tienen tamaños diferentes es posible llegar a
-	dividir de tal modo el área de memoria libre que sea
-	inutilizable. Es decir, el espacio puede estar disponible,
-	pero debido al nivel de fragmentación alcanzado, no exista
-	ningún bloque del tamaño requerido. Es posible asegurarse de
-	que esto no llegue a ocurrir mediante la creación de un
-	asignador para una clase específica.
+		Otra cuestión es la fragmentación del montículo. Cuando los objetos tienen tamaños
+		diferentes es posible llegar a dividir de tal modo el área de memoria libre que se
+		vuelva inútil. Es decir, el espacio puede estar disponible, pero debido al nivel
+		de fragmentación alcanzado, no exista ningún bloque del tamaño requerido. Es
+		posible asegurarse de que esto no llegue a ocurrir mediante la creación de un
+		asignador para una clase específica.
       </para>
 
     <!--
     A custom memory allocator is the solution; otherwise, programmers will avoid using new
     and delete altogether in such cases and miss out on a valuable C++ asset.
     -->
-      <para>
-	En los sistemas de tiempo real y en los sistemas integrados,
-	suele ser necesario que los programas funcionen por largo tiempo
-	con recursos muy limitados. Tales sistemas pueden incluso
-	requerir que cada asignación tome siempre la misma cantidad de
-	tiempo, y que no esté permitida la fragmentación ni el
-	agotamiento en el área dinámica. La solución a este problema
-	consiste en utilizar un asignador <quote>personalizado</quote>;
-	de otro modo, los programadores evitarían usar
-	<kw>new</kw> y <kw>delete</kw> es estos
-	casos y desperdiciarían un recurso muy valioso de
-	C++.
-      </para>
+	<para>
+	  En los sistemas de tiempo real y en los sistemas integrados, suele ser necesario que
+	  los programas funcionen por largo tiempo con recursos muy limitados. Tales sistemas
+	  pueden incluso requerir que cada asignación tome siempre la misma cantidad de
+	  tiempo, y que no esté permitida la fragmentación ni el agotamiento en el área
+	  dinámica. La solución a este problema consiste en utilizar un asignador
+	  <quote>personalizado</quote>; de otro modo, los programadores evitarían usar
+	  <kw>new</kw> y <kw>delete</kw> es estos casos y desperdiciarían un recurso muy
+	  valioso de C++.
+	</para>
 
     <!--
     When you overload operator new( ) and operator delete( ), it’s important to remember
     allocation portion. (delete has a similar limitation.)
     -->
       <para>
-	A la hora de sobrecargar <function>operator new()</function> y
-	<function>operator delete()</function> es importante tener en
-	cuenta que lo único que se está cambiando es la forma en que se
-	realiza la asignación del espacio. El compilador llamará a la
-	nueva versión de <kw>new</kw> en lugar de al original,
-	para asignar espacio, llamando después al constructor que
-	actuará sobre él. Así que, aunque el compilador convierte una
-	expresión <kw>new</kw> en código para asignar el
-	espacio y para llamar al constructor, todo lo que se puede
-	cambiar al sobrecargar <kw>new</kw> es la parte
-	correspondiente a la asignación. (<kw>delete</kw>
-	tiene una limitación similar.
+		A la hora de sobrecargar <function>operator new()</function> y <function>operator
+		delete()</function> es importante tener en cuenta que lo único que se está
+		cambiando es la forma en que se realiza la asignación del espacio. El compilador
+		llamará a la nueva versión de <kw>new</kw> en lugar de al original, para asignar
+		espacio, llamando después al constructor que actuará sobre él. Así que, aunque el
+		compilador convierte una expresión <kw>new</kw> en código para asignar el espacio
+		y para llamar al constructor, todo lo que se puede cambiar al sobrecargar
+		<kw>new</kw> es la parte correspondiente a la asignación. <kw>delete</kw> tiene
+		una limitación similar.
       </para>
 
     <!--
     (discussed in Volume 2, available at www.BruceEckel.com).
     -->
       <para>
-	Cuando se sobrecarga <function>operator new()</function>, se
-	está reemplazando también el modo de tratar los posibles fallos
-	en la asignación de la memoria. Se debe decidir qué acciones va
-	a realizar en tal caso: devolver cero, un bucle de reintento
-	con llamada al <foreignphrase>new-handler</foreignphrase>, o lo
-	que es más frecuente, disparar una excepción
-	<emphasis>bad_alloc</emphasis> (tema que se trata en el
-	Volumen 2).
+		Cuando se sobrecarga <function>operator new()</function>, se está reemplazando
+		también el modo de tratar los posibles fallos en la asignación de la memoria. Se
+		debe decidir qué acciones va a realizar en tal caso: devolver cero, un bucle de
+		reintento con llamada al <foreignphrase>new-handler</foreignphrase>, o lo que es
+		más frecuente, disparar una excepción <emphasis>bad_alloc</emphasis> (tema que se
+		trata en el Volumen 2).
       </para>
 
     <!--
     particular class.
     -->
       <para>
-	La sobrecarga de <kw>new</kw> y
-	<kw>delete</kw> es como la de cualquier otro
-	operador.  Existe la posibilidad de elegir entre sobrecarga
-	global y sobrecarga para una clase determinada.
+		La sobrecarga de <kw>new</kw> y <kw>delete</kw> es como la de cualquier otro
+		operador. Existe la posibilidad de elegir entre sobrecarga global y sobrecarga
+		para una clase determinada.
       </para>
 
       <sect3>
       <!-- : Overloading global new & delete -->
-	<title>Sobrecarga global de <kw>new</kw> y
-	<kw>delete</kw></title>
+	  <title>Sobrecarga global de <kw>new</kw> y <kw>delete</kw></title>
 
       <!--
       This is the drastic approach, when the global versions of new and delete are
       defaults completely inaccessible – you can’t even call them from inside your
       redefinitions.
       -->
-	<para>
-	  Este es el modo más drástico de abordar el asunto, resulta
-	  útil cuando el comportamiento de <kw>new</kw> y
-	  <kw>delete</kw> no es satisfactorio para la mayor
-	  parte del sistema.  Al sobrecargar la versión global, quedan
-	  inaccesibles las originales, y ya no es posible llamarlas
-	  desde dentro de las funciones sobrecargadas.
-	</para>
+	  <para>
+		Este es el modo más drástico de abordar el asunto, resulta útil cuando el
+		comportamiento de <kw>new</kw> y <kw>delete</kw> no es satisfactorio para la mayor
+		parte del sistema.  Al sobrecargar la versión global, quedan inaccesibles las
+		originales, y ya no es posible llamarlas desde dentro de las funciones
+		sobrecargadas.
+	  </para>
 
       <!--
       The overloaded new must take an argument of size_t (the Standard C standard type for
       returning zero, like calling the new-handler or throwing an exception, to signal that
       there’s a problem.
       -->
-	<para>
-	  El <kw>new</kw> sobrecargado debe tomar un argumento
-	  del tipo <type>size_t</type> (el estándar de
-	  C) para tamaños. Este argumento es
-	  generado y pasado por el compilador, y se refiere al tamaño
-	  del objeto para el que ahora tenemos la responsabilidad de la
-	  asignación de memoria. Debe devolver un puntero a un bloque de
-	  ese tamaño, (o mayor, si hubiera motivos para hacerlo así), o
-	  cero en el caso de no se encontrara un bloque adecuado. Si
-	  eso sucede, no se producirá la llamada al constructor. Por
-	  supuesto, hay que hacer algo más informativo que sólo
-	  devolver cero, por ejemplo llamar al
-	  <quote>new-handler</quote> o disparar una excepción, para
-	  indicar que hubo un problema.
-	</para>
+	  <para>
+		El <kw>new</kw> sobrecargado debe tomar un argumento del tipo <type>size_t</type>
+		(el estándar de C) para tamaños. Este argumento es generado y pasado por el
+		compilador, y se refiere al tamaño del objeto para el que ahora tenemos la
+		responsabilidad de la asignación de memoria. Debe devolver un puntero a un bloque
+		de ese tamaño, (o mayor, si hubiera motivos para hacerlo así), o cero en el caso
+		de no se encontrara un bloque adecuado. Si eso sucede, no se producirá la llamada
+		al constructor. Por supuesto, hay que hacer algo más informativo que sólo devolver
+		cero, por ejemplo llamar al <quote>new-handler</quote> o disparar una excepción,
+		para indicar que hubo un problema.
+	  </para>
 
       <!--
       The return value of operator new( ) is a void*, not a pointer to any particular type.
       All you’ve done is produce memory, not a finished object – that doesn’t happen until the
       constructor is called, an act the compiler guarantees and which is out of your control.
       -->
-	<para>
-	  El valor de retorno del <function>operator new()</function> es
-	  <type>void*</type>, no un puntero a un tipo particular. Lo que
-	  hace es obtener un bloque de memoria, no un objeto definido,
-	  no hasta que que sea llamado el constructor, un acto que el
-	  compilador garantiza y que está fuera del control de  este
-	  operador.
-	</para>
+	  <para>
+		El valor de retorno de <function>operator new()</function> es <type>void*</type>,
+		no un puntero a un tipo particular. Lo que hace es obtener un bloque de memoria,
+		no un objeto definido, no hasta que que sea llamado el constructor, un acto que el
+		compilador garantiza y que está fuera del control de este operador.
+	  </para>
 
       <!--
       The operator delete( ) takes a void* to memory that was allocated by operator new. It’s
       a void* because operator delete only gets the pointer after the destructor is called,
       which removes the object-ness from the piece of storage. The return type is void.
       -->
-	<para>
-	  El operador <function>operator delete()</function> toma como
-	  argumento un puntero <type>void*</type> a un bloque obtenido
-	  con el <function>operator new()</function>. Es un
-	  <type>void*</type> ya que el <kw>delete</kw> obtiene
-	  el puntero sólo <emphasis>después</emphasis> de que haya sido
-	  llamado el destructor, lo que efectivamente elimina su
-	  caracter de objeto convirtiéndolo en un simple bloque de
-	  memoria. El tipo de retorno para <kw>delete</kw> es
-	  <type>void</type>.
-	</para>
+	  <para>
+		El operador <function>operator delete()</function> toma como argumento un puntero
+		<type>void*</type> a un bloque obtenido con el <function>operator
+		new()</function>. Es un <type>void*</type> ya que el <kw>delete</kw> obtiene el
+		puntero sólo <emphasis>después</emphasis> de que haya sido llamado el destructor,
+		lo que efectivamente elimina su caracter de objeto convirtiéndolo en un simple
+		bloque de memoria. El tipo de retorno para <kw>delete</kw> es <type>void</type>.
+	  </para>
 
       <!-- Here’s a simple example showing how to overload the global new and delete: -->
-	<para>
-	  A continuación se expone un ejemplo del modo de sobrecargar
-	  globalmente <kw>new</kw> y
-	  <kw>delete</kw>:
-	</para>
+	  <para>
+		A continuación se expone un ejemplo del modo de sobrecargar globalmente
+		<kw>new</kw> y <kw>delete</kw>:
+	  </para>
 
 
 //: V1C13:GlobalOperatorNew.cpp
       calls new to allocate memory. With printf( ), you don’t get into a deadlock because it
       doesn’t call new to initialize itself.
       -->
-	<para>
-	  Aquí puede verse la forma general de sobrecarga de operadores
-	  <kw>new</kw> y <kw>delete</kw>.  Estos
-	  operadores sustitutivos usan las funciones
-	  <function>malloc()</function> y <function>free()</function> de
-	  la bliblioteca estándar de C, que es probablemente lo que
-	  ocurre en los operadores originales. Imprimen también mensajes
-	  sobre lo que están haciendo. Nótese que no se han usado
-	  <literal>iostreams</literal> sino
-	  <function>printf()</function> y
-	  <function>puts()</function>. Esto se hace debido a que los
-	  objetos <type>iostream</type> como los globales
-	  <varname>cin</varname>, <varname>cout</varname> y
-	  <varname>cerr</varname> llaman a <kw>new</kw> para
-	  obtener memoria <footnote><para> Provocaría una serie continua
-	  de llamadas a <kw>new</kw> hasta que agotada el área
-	  de la pila y abortara el programa.</para></footnote>. Usar
-	  <function>printf()</function> evita el fatal bloqueo, ya que
-	  no hace llamadas a <kw>new</kw>.
+	  <para>
+	  Aquí <p></p>uede verse la forma general de sobrecarga de operadores <kw>new</kw> y
+	  <kw>delete</kw>.  Estos operadores sustitutivos usan las funciones
+	  <function>malloc()</function> y <function>free()</function> de la biblioteca
+	  estándar de C, que es probablemente lo que ocurre en los operadores
+	  originales. Imprimen también mensajes sobre lo que están haciendo. Nótese que no se
+	  han usado <literal>iostreams</literal> sino <function>printf()</function> y
+	  <function>puts()</function>. Esto se hace debido a que los objetos
+	  <type>iostream</type> como los globales <varname>cin</varname>,
+	  <varname>cout</varname> y <varname>cerr</varname> llaman a <kw>new</kw> para obtener
+	  memoria <footnote><para>Provocaría una serie continua de llamadas a <kw>new</kw>
+	  hasta agotar la pila y abortaría el programa.</para></footnote>. Usar
+	  <function>printf()</function> evita el fatal bloqueo, ya que no hace llamadas a
+	  <kw>new</kw>.
 	</para>
 
       <!--
       objects it holds. In all cases, the global overloaded versions of new and delete are
       used.
       -->
-	<para>
-	  En <function>main()</function>, se crean algunos objetos de
-	  tipos básicos para demostrar que también en estos casos se
-	  llama a los operadores <kw>new</kw> y
-	  <kw>delete</kw> sobrecargados. Posteriormente, se
-	  crean un objeto simple y un vector, ambos de tipo
-	  <classname>S</classname>. En el caso del vector se puede ver,
-	  por el número de bytes pedidos, que se solicita algo de
-	  memoria extra para incluir información sobre el número de
-	  objetos que tendrá. En todos los casos se efectúa la llamada a
-	  las versiones globales sobrecargadas de <kw>new</kw>
-	  y <kw>delete</kw>.
-	</para>
+	  <para>
+		En <function>main()</function>, se crean algunos objetos de tipos básicos para
+		demostrar que también en estos casos se llama a los operadores <kw>new</kw> y
+		<kw>delete</kw> sobrecargados. Posteriormente, se crean un objeto simple y un
+		vector, ambos de tipo <classname>S</classname>. En el caso del vector se puede
+		ver, por el número de bytes pedidos, que se solicita algo de memoria extra para
+		incluir información sobre el número de objetos que tendrá. En todos los casos se
+		efectúa la llamada a las versiones globales sobrecargadas de <kw>new</kw> y
+		<kw>delete</kw>.
+	  </para>
 
-      </sect3>
+	</sect3>
 
 
-      <sect3>
+	<sect3>
       <!-- : Overloading new & delete for a class -->
-	<title>
-	  Sobrecarga de <kw>new</kw> y
-	  <kw>delete</kw> específica para una clase
-	</title>
+	  <title>
+		Sobrecarga de <kw>new</kw> y <kw>delete</kw> específica para una clase
+	  </title>
 
       <!--
       Although you don’t have to explicitly say static, when you overload new and delete for a
       the global versions of new and delete are used for all other types of objects (unless
       they have their own new and delete).
       -->
-	<para>
-	  Aunque no es necesario poner el modificador
-	  <kw>static</kw>, cuando se sobrecarga
-	  <kw>new</kw> y <kw>delete</kw> para una
-	  clase se están creando funciones miembro estáticas (métodos de
-	  clase). La sintasis es la misma que para cualquier otro
-	  operador. Cuando el compilador encuentra una expresión
-	  <kw>new</kw> para crear un objeto de una clase,
-	  elige, si existe, un método de la clase llamado
-	  <function>operator new()</function> en lugar del
-	  <kw>new</kw> global. Para el resto de tipos o clases
-	  se usan los operadores globales (a menos que tengan definidos
-	  los suyos propios).
-	</para>
+	  <para>
+		Aunque no es necesario poner el modificador <kw>static</kw>, cuando se sobrecarga
+		<kw>new</kw> y <kw>delete</kw> para una clase se están creando métodos estáticos
+		(métodos de clase). La sintaxis es la misma que para cualquier otro
+		operador. Cuando el compilador encuentra una expresión <kw>new</kw> para crear un
+		objeto de una clase, elige, si existe, un método de la clase llamado
+		<function>operator new()</function> en lugar del <kw>new</kw> global. Para el
+		resto de tipos o clases se usan los operadores globales (a menos que tengan
+		definidos los suyos propios).
+	  </para>
 
 
-<!--
- In the following example, a primitive storage allocation system is
- created for the class Framis. A chunk of memory is set aside in the
- static data area at program start-up, and that memory is used to
- allocate space for objects of type Framis. To determine which blocks
- have been allocated, a simple array of bytes is used, one byte for each
- block:
--->
-	<para>
-	  En el siguiente ejemplo se usa un primitivo sistema de
-	  asignación de almacenamiento para la clase
-	  <classname>Framis</classname>. Se reserva un bloque de memoria
-	  en el área de datos estática FIXME , y se usa esa memoria para
-	  asignar alojamiento para los objetos de tipo
-	  <classname>Framis</classname>. Para determinar que bloques se
-	  han asignado, se una un sencillo vector de bytes, un byte por
-	  bloque.
-	</para>
+	  <!--
+		  In the following example, a primitive storage allocation system is created for
+		  the class Framis. A chunk of memory is set aside in the static data area at
+		  program start-up, and that memory is used to allocate space for objects of type
+		  Framis. To determine which blocks have been allocated, a simple array of bytes
+		  is used, one byte for each block:
+	  -->
+	  <para>
+		En el siguiente ejemplo se usa un primitivo sistema de asignación de
+		almacenamiento para la clase <classname>Framis</classname>. Se reserva un bloque
+		de memoria en el área de datos estática FIXME , y se usa esa memoria para asignar
+		alojamiento para los objetos de tipo <classname>Framis</classname>. Para
+		determinar qué bloques se han asignado, se usa un sencillo vector de bytes, un
+		byte por bloque.
+	  </para>
 
 
 //: V1C13:Framis.cpp
       compiler automatically initializes all the rest to their normal default value (which is
       false, in the case of bool).
       -->
-	<para>
-	  El espacio de almacenamiento para el montículo
-	  <classname>Framis</classname> se crea sobre el bloque obtenido
-	  al declarar un vector de tamaño suficiente para contener
-	  <varname>psize</varname> objetos de clase
-	  <classname>Framis</classname>. Se ha declarado también una
-	  variable lógica para cada uno de los <varname>psize</varname>
-	  bloques en el vector. Todas estas variables lógicas son
-	  inicializadas a <constant>false</constant> usando el truco
-	  consistente en inicializar el primer elemento para que el
-	  compilador lo haga automáticamente con los restantes
-	  iniciándolos a su valor por defecto,
-	  <constant>false</constant>, en el caso de variables lógicas.
+	  <para>
+		El espacio de almacenamiento para el montículo <classname>Framis</classname> se
+		crea sobre el bloque obtenido al declarar un vector de tamaño suficiente para
+		contener <varname>psize</varname> objetos de clase
+		<classname>Framis</classname>. Se ha declarado también una variable lógica para
+		cada uno de los <varname>psize</varname> bloques en el vector. Todas estas
+		variables lógicas son inicializadas a <constant>false</constant> usando el truco
+		consistente en inicializar el primer elemento para que el compilador lo haga
+		automáticamente con los restantes iniciándolos a su valor por defecto,
+		<constant>false</constant>, en el caso de variables lógicas.
 	</para>
 
       <!--
       If it can’t find any memory, it issues a message to the trace file and throws a
       bad_alloc exception.
       -->
-	<para>
-	  El <function>operador new()</function> local usa la misma
-	  sintaxis que el global. Lo único que hace es buscar una
-	  posición libre, es decir, un valor <constant>false</constant>
-	  en el mapa de localizacíon <varname>alloc_map</varname>. Si la
-	  encuentra, cambia su valor a <constant>true</constant> para
-	  marcarla como ocupada, y devuelve la dirección del bloque
-	  correspondiente. En caso de no encontrar ningún bloque libre,
-	  envía un mensaje al fichero de trazas y dispara una excepción
-	  de tipo <type>bad_alloc</type>.
+	  <para>
+		El <function>operador new()</function> local usa la misma sintaxis que el
+		global. Lo único que hace es buscar una posición libre, es decir, un valor
+		<constant>false</constant> en el mapa de localización
+		<varname>alloc_map</varname>. Si la encuentra, cambia su valor a
+		<constant>true</constant> para marcarla como ocupada, y devuelve la dirección del
+		bloque correspondiente. En caso de no encontrar ningún bloque libre, envía un
+		mensaje al fichero de trazas y dispara una excepción de tipo
+		<type>bad_alloc</type>.
 	</para>
 
       <!--
       When an exception is thrown, the function stops executing and control is passed to an
       exception handler, which is expressed as a catch clause.
       -->
-	<para>
-	  Este es el primer ejemplo con excepción que aparece en este
-	  libro.  En el Volumen 2 se verá una discusión detallada del
-	  tratamiento de excepciones, por lo que en este ejemplo se hace
-	  un uso muy simple del mismo. El <function>operador
-	  new</function> hay dos expresiones relacionadas con el
-	  tratamiento de excepciones. Primero, a la lista de argumentos
-	  de función le sigue la expresión
-	  <literal>throw(bad_alloc)</literal>, esto informa al
-	  compilador que la función puede disparar una excepción del
-	  tipo indicado. En segundo lugar, si efectivamente se agota la
-	  memoria, la función alcanzará la sentencia <literal>throw
-	  bad_alloc()</literal> lanzando la excepción. En el caso de que
-	  esto ocurra, la función deja de ejecutarse y se cede el
-	  control del programa a la rutina de tratamiento de excepción
-	  que se ha definido en una cláusula
-	  <literal>catch(bad_alloc)</literal>.
-	</para>
+	  <para>
+		Este es el primer ejemplo con excepción que aparece en este libro.  En
+		el Volumen 2 se verá una discusión detallada del tratamiento de
+		excepciones, por lo que en este ejemplo se hace un uso muy simple del
+		mismo. En el <function>operador new</function> hay dos expresiones
+		relacionadas con el tratamiento de excepciones. Primero, a la lista de
+		argumentos de función le sigue la expresión
+		<code>throw(bad_alloc)</code>, esto informa al compilador que la
+		función puede disparar una excepción del tipo indicado. En segundo
+		lugar, si efectivamente se agota la memoria, la función alcanzará la
+		sentencia <code>throw bad_alloc()</code> lanzando la excepción. En el
+		caso de que esto ocurra, la función deja de ejecutarse y se cede el
+		control del programa a la rutina de tratamiento de excepción que se ha
+		definido en una cláusula <code>catch(bad_alloc)</code>.
+     </para>
 
       <!--
       In main( ), you see the other part of the picture, which is the try-catch clause. The
       thrown, and execution continues after the end of the last catch clause in the group
       (there’s only one here, but there could be more).
       -->
-	<para>
-	  En <function>main()</function> se puede ver la cláusula
-	  <emphasis>try-catch</emphasis> que es la otra parte del
-	  mecanismo. El código que puede lanzar la excepción queda
-	  dentro del bloque <kw>try</kw>; en este caso,
-	  llamadas a <kw>new</kw> para objetos
-	  <classname>Framis</classname>. Justo a continuación de dicho
-	  bloque sigue una o varias cláusulas <kw>catch</kw>,
-	  especificando en cada una la excepción a la que se destina. En
-	  este caso, <literal>catch(bad_alloc)</literal> indica que en
-	  ese bloque se tratarán las excepciones de tipo
-	  <type>bad_alloc</type>.  El código de este bloque sólo se
-	  ejecutará si se dispara la excepción, continuando la ejecución
-	  del programa justo después de la última del grupo de cláusulas
-	  <kw>catch</kw> que existan. Aquí sólo hay una, pero
-	  podría haber más.
-	</para>
+		<para>
+		  En <function>main()</function> se puede ver la cláusula
+		  <emphasis>try-catch</emphasis> que es la otra parte del mecanismo. El
+		  código que puede lanzar la excepción queda dentro del bloque
+		  <kw>try</kw>; en este caso, llamadas a <kw>new</kw> para objetos
+		  <classname>Framis</classname>. Justo a continuación de dicho bloque
+		  sigue una o varias cláusulas <kw>catch</kw>, especificando en cada una
+		  la excepción a la que se destina. En este caso,
+		  <code>catch(bad_alloc)</code> indica que en ese bloque se
+		  tratarán las excepciones de tipo <type>bad_alloc</type>.  El código de
+		  este bloque sólo se ejecutará si se dispara la excepción, continuando
+		  la ejecución del programa justo después de la última del grupo de
+		  cláusulas <kw>catch</kw> que existan. Aquí sólo hay una, pero podría
+		  haber más.
+		</para>
 
       <!--
       In this example, it’s OK to use iostreams because the global operator new( ) and delete(
       ) are untouched.
       -->
-	<para>
-	  En este ejemplo, el uso de <literal>iostream</literal> es
-	  correcto ya que el <function>operator new()</function> global
-	  no ha sido modificado.
-	</para>
+		<para>
+		  En este ejemplo, el uso de <literal>iostream</literal> es correcto ya
+		  que el <function>operator new()</function> global no ha sido modificado.
+		</para>
 
       <!--
       The operator delete( ) assumes the Framis address was created in the pool. This is a
       within the pool and on a correct boundary (you may also begin to see the potential of
       overloaded new and delete for finding memory leaks).
       -->
-	<para>
-	  El <function>operator delete()</function> asume que la
-	  dirección de <classname>Framis</classname> ha sido obtenida de
-	  nuestro almacén particular. Una asunción justa, ya que cada
-	  vez que se crea un objeto <classname>Framis</classname> simple
-	  se llama al <function>operator new()</function> local; pero
-	  cuando se crea un vector de tales objetos se llama al
-	  <kw>new</kw> global. Esto causaría problemas si el
-	  usuario llamara accidentalmente al operador
-	  <kw>delete</kw> sin usar la sintaxis para
-	  destrucción de vectores. Podría ser que incluso estuviera
-	  tratando de borrar un puntero a un objeto de la pila. Si se
-	  cree que estas cosas pudiedeb suceder, conviene pensar en
-	  añadir una línea que asegurare que la dirección está en el
-	  intervalo correcto (aquí se demuestra el potencial que tiene
-	  la sobrecarga de los operadores <kw>new</kw> y
-	  <kw>delete</kw> para la localizacíon de fugas de
-	  memoria).
-	</para>
+		<para>
+		  El <function>operator delete()</function> asume que la dirección de
+		  <classname>Framis</classname> ha sido obtenida de nuestro almacén
+		  particular. Una asunción justa, ya que cada vez que se crea un objeto
+		  <classname>Framis</classname> simple se llama al <function>operator
+		  new()</function> local; pero cuando se crea un vector de tales objetos
+		  se llama al <kw>new</kw> global. Esto causaría problemas si el usuario
+		  llamara accidentalmente al operador <kw>delete</kw> sin usar la
+		  sintaxis para destrucción de vectores. Podría ser que incluso
+		  estuviera tratando de borrar un puntero a un objeto de la pila. Si
+		  cree que estas cosas puedan suceder, conviene pensar en añadir una
+		  línea que asegurare que la dirección está en el intervalo correcto
+		  (aquí se demuestra el potencial que tiene la sobrecarga de los
+		  operadores <kw>new</kw> y <kw>delete</kw> para la localización de
+		  fugas de memoria).
+		</para>
 
       <!--
       operator delete( ) calculates the block in the pool that this pointer represents, and
       then sets the allocation map’s flag for that block to false to indicate the block has
       been released.
       -->
-	<para>
-	  <function>operador delete()</function> calcula el bloque al
-	  que el puntero representa y después pone a
-	  <constant>false</constant> la bandera correspondiente en el
-	  mapa de localización, para indicar que dicho bloque está
-	  libre.
-	</para>
+		<para>
+		  <function>operador delete()</function> calcula el bloque al que el
+		  puntero representa y después pone a <constant>false</constant> la
+		  bandera correspondiente en el mapa de localización, para indicar que
+		  dicho bloque está libre.
+		</para>
 
       <!--
       In main( ), enough Framis objects are dynamically allocated to run out of memory; this
       checks the out-of-memory behavior. Then one of the objects is freed, and another one is
       created to show that the released memory is reused.
       -->
-	<para>
-	  En la función <function>main()</function>, se crean
-	  dinámicamente suficientes objetos Framis para agotar la
-	  memoria. Con esto se prueba el comportamiento del programa en
-	  este caso. A continuación, se libera uno de los objetos y se
-	  crea otro para mostrar la reutilización del bloque recién
-	  liberado.
-	</para>
+		<para>
+		  En la función <function>main()</function>, se crean dinámicamente
+		  suficientes objetos <classname>Framis</classname> para agotar la
+		  memoria. Con esto se prueba el comportamiento del programa en este
+		  caso. A continuación, se libera uno de los objetos y se crea otro para
+		  mostrar la reutilización del bloque recién liberado.
+		</para>
 
 
       <!--
       However, you should note that it doesn’t automatically work if inheritance is used
       (inheritance is covered in Chapter 14).
       -->
-	<para>
-	  Este esquema específico de asignación de memoria es
-	  probablemente mucho más rápido que el esquema de propósito
-	  general que usan los operadores <kw>new</kw> y
-	  <kw>delete</kw> originales. Se debe advertir, no
-	  obstante, que este enfoque no es automáticamente utilizable
-	  cuando se usa herencia, un tema que verá en el Capítulo 14.
-	</para>
+		<para>
+		  Este esquema específico de asignación de memoria es probablemente
+		  mucho más rápido que el esquema de propósito general que usan los
+		  operadores <kw>new</kw> y <kw>delete</kw> originales. Se debe
+		  advertir, no obstante, que este enfoque no es automáticamente
+		  utilizable cuando se usa herencia, un tema que verá en el Capítulo 14 (FIXME).
+		</para>
       </sect3>
 
+
+<!-- revisando por aquí -->
+
       <!-- 603 -->
       <sect3>
-		      <!-- : Overloading new & delete for arrays -->
-	<title>
-	  Sobrecarga de <kw>new</kw> y
-	  <kw>delete</kw> para vectores
-	</title>
+		<!-- : Overloading new & delete for arrays -->
+
+		<title>Sobrecarga de <kw>new</kw> y <kw>delete</kw> para vectores</title>
 
       <!--
       If you overload operator new and delete for a class, those operators are called whenever