A41369- A55609 Tarea Programada 2: ADH

00001 // ADH_port.h (c) 2005 [email protected]
00002 
00003 /** \file  ADH_port.h
00004     \brief Encabezado para que los programas puedan ser compilados
00005            con varios compiladores
00006 
00007     Este archivo de encabezado permite compilar los programas de
00008     \c [email protected] usando cualquiera de estos compiladores:
00009     - Microsoft C++ .NET
00010     - Microsoft C++ v6
00011     - Borland C++ v3.1
00012 
00013     \par Uso de \c "namespace"
00014 
00015     Para permitir que el código sea compilador con el Borland C++ v3.1, que no
00016     permite usar \c "namespace", los programas están escritos usando estas
00017     macros, que sirven para iniciar, usar y terminar un \c "namespace":
00018     - <code>OPEN_namespace(N) // namespace N { </code>
00019     - <code>USING_namespace(N) // using namespace N </code>
00020     - <code>CLOSE_namespace(N)  // } // namespace N </code>
00021 
00022     \par Uso de \c "#include"
00023 
00024     El compilador C++ de Visual Studio .NET usa nombres de archivos de
00025     encabezado que no tienen el sufijo \c ".h". Por ejemplo, para
00026     usar un flujo de entrada, el programador debe incluir estas líneas:
00027     - MSC++ v6 ====> <code> # include &lt;iostream.h&gt; // con \c ".h" </code>
00028     - MSC++ .NET ==> <code> # include &lt;iostream&gt; // SIN \c ".h" </code>
00029 
00030     Para incluir el archivo de encabezado correcto es necesario establecer cuál
00031     compilador se está usando. Para evitar usar varias directivas <code> #&nbsp;ifdef</code>, se
00032     puede definir una macro que indica cuál archivos de encabezado incluir. No todos los
00033     encabezados estándar están incorporados aquí, pero sí los más usados. Por ejemplo, para
00034     usar el archvio de encabadezdos \c &lt;iostream&gt; basta incluir en el código fuente la
00035     definición de este macro:
00036     - <code> \c # define  INCLUDE_iostream </code>
00037 
00038     \par Diferencias entre MSC++ v6 y MSC++ .NET
00039 
00040     Lo usual es encontrar código escrito para la versión vieja del compilador de Microsoft,
00041     el MSC++ v6.0 o anterior. Con frecuencia, basta hacer estas modificaciones para que
00042     el código pueda ser compilador con MSC++ .NET:
00043 
00044     - Agregar el renglón <code> using namespace std; </code> <br>
00045     - Eliminar el \c ".h" de los encabezados estándar
00046        [por ejemplo, cambiar &lt;iostream.h&gt; por &lt;iostream&gt;]
00047     - En muchos casos, es necesario eliminar el \c ".h" cuando se usan archivos de
00048       encabezado de la biblioteca estándar C
00049        [por ejemplo, cambiar &lt;stdlib.h&gt; por &lt;cstdlib&gt;]
00050     - En otros casos, es necesario usar el nombre antiguo del archivo de encabezado
00051        [por ejemplo, sí sirve &lt;math.h&gt; pero no sirve &lt;cmath&gt;]
00052 
00053     \par Borland C++ v3.1
00054 
00055     En algunas ocasiones conviene más usar el compilador BC++ v3.1 porque es un
00056     compilador que requiere muy pocos recursos traducir programas.Desafortundamente,
00057     el  BC++ v3.1 tiene varias restricciones de funcionamiento entre las que se
00058     destacan éstas:
00059 
00060     - No tiene definido el tipo \c "bool"
00061     - No permite usar \c "namespace"
00062     - No permite usar excepciones
00063     - No usa correctamente las reglas de conversi¢n de tipos
00064 
00065     Algunos ejemplos C++ son sólo puedes ser expresado correctamente
00066     usando el lenguaje C++ moderno, est ndar. Pero muchos otros no
00067     requieren tanta expresividad por lo que pueden ser compilados con
00068     BC++ v3.1. Para lograrlo es necesario usar.
00069 
00070     \par Ejemplo de uso
00071     \code
00072     #ifndef String_h
00073     #define String_h // Evita la inclusión múltiple
00074 
00075     #define  INCLUDE_iostream // ==> # include <iostream>
00076     #include "ADH_port.h"
00077 
00078     OPEN_namespace(ADH)
00079     USING_namespace(std); // es necesario agregar el punto y coma
00080 
00081     class String{
00082         // ...
00083     };
00084 
00085     CLOSE_namespace(ADH)
00086 
00087     USING_namespace(ADH); // es necesario agregar el ";"
00088     ADH::String& operator<<( std::ostream COUT&; ADH::String& s);
00089 
00090     #endif // String_h
00091     \endcode
00092 
00093     \par Resultado en Borland C++ v3.1
00094     \code
00095     #ifndef String_h
00096     #define String_h // Evita la inclusión múltiple
00097 
00098     #include <iostream.h>
00099     #include "ADH_port.h"
00100 
00101     // namespace ADH {       //  ==> eliminado
00102     ; // using namespace std // ==> eliminado
00103 
00104     class String{
00105         // ...
00106     };
00107 
00108     // }  ==> eliminado
00109 
00110     // using namespace ADH;  // ==> eliminado  // ADH && std ==> eliminado
00111     ::String& operator<<( ::ostream COUT&; ::String& s);
00112 
00113     #endif // String_h
00114     \endcode
00115 
00116     \par Resultado en Microsft C++ .NET
00117     \code
00118     #ifndef String_h
00119     #define String_h // Evita la inclusión múltiple
00120 
00121     #include <iostream> // sin ".h"
00122     #include "ADH_port.h"
00123     using namespace std; // Agregado en "ADH_port.h"
00124 
00125     namespace ADH {
00126     using namespace std;
00127 
00128     class String{
00129         // ...
00130     };
00131 
00132     } // namespace ADH
00133 
00134     using namespace ADH;
00135     ADH::String& operator<<( std::ostream COUT&; ADH::String& s);
00136 
00137     #endif // String_h
00138     \endcode
00139 
00140     \author Adolfo Di Mare <[email protected]>
00141     \date   2005
00142 */
00143 
00144 #ifndef ADH_port_h
00145 #define ADH_port_h ///< Evita la inclusión múltiple
00146 
00147 // Documentados acá para Doxygen
00148 #undef  CLOSE_namespace
00149 #undef  USING_namespace
00150 #undef  OPEN_namespace
00151 
00152 /// Abre namespace   \c "N"
00153 #define OPEN_namespace(N) namespace N {
00154 
00155 /// Cierra namespace \c "N"
00156 #define CLOSE_namespace(N) }
00157 
00158 /// Usa namespace    \c "N"
00159 #define USING_namespace(N) using namespace N
00160 
00161 // Los anula para luego definirlos dentro del #ifdef correcto
00162 #undef  CLOSE_namespace
00163 #undef  USING_namespace
00164 #undef  OPEN_namespace
00165 
00166 #ifdef DOXYGEN_COMMENT   // Documentados acá para Doxygen
00167     /// Definido por la biblioteca C++ estándar
00168     namespace std {} // Está acá para que Doxygen lo documente
00169     /// ADH son las siglas de \c [email protected]
00170     namespace ADH {} // Está acá para que Doxygen lo documente
00171     #define INCLUDE_fstream   Truco para "include <fstream>"   portable
00172     #define INCLUDE_io        Truco para "include <io>"        portable
00173     #define INCLUDE_iomanip   Truco para "include <iomanip>"   portable
00174     #define INCLUDE_iostream  Truco para "include <iostream>"  portable
00175     #define INCLUDE_list      Truco para "include <list>"      portable
00176     #define INCLUDE_map       Truco para "include <map>"       portable
00177     #define INCLUDE_stdexcept Truco para "include <stdexcept>" portable
00178     #define INCLUDE_vector    Truco para "include <vector>"    portable
00179 #endif
00180 
00181 // Borland C++
00182 #ifdef __BORLANDC__               ///< Definida para Borland C++
00183     #if (__BORLANDC__ <= 0x0410)  //   Identifica a BC++ v3.1 y anterior
00184 
00185         // Declara el tipo "bool" porque BC++ v3.1 NO tiene "bool"
00186         #ifndef _bool_h
00187         #define _bool_h
00188             #undef false
00189             #undef true
00190             #undef bool
00191 
00192             typedef int bool;
00193             const int false = 0;
00194             const int true  = ! false; // BC++ v3.1 NO tiene "bool"
00195         #endif
00196 
00197         class istream; class ostream;
00198 
00199         #define using              // BC++ v3.1 NO tiene "namespace"
00200         #define namespace
00201         #define std
00202         #define ADH
00203 
00204         #define OPEN_namespace(N)  // BC++ v3.1 NO tiene "namespace"
00205         #define CLOSE_namespace(N)
00206         #define USING_namespace(N)
00207 
00208         #ifdef INCLUDE_fstream
00209             #include  <fstream.h>
00210         #endif
00211         #ifdef INCLUDE_io
00212             #include  <io.h>
00213         #endif
00214         #ifdef INCLUDE_iomanip
00215             #include  <iomanip.h>
00216         #endif
00217         #ifdef INCLUDE_iostream
00218             #include  <iostream.h>
00219         #endif
00220         #ifdef INCLUDE_list
00221             #include  <list.h>
00222         #endif
00223         #ifdef INCLUDE_map
00224             #include  <map.h>
00225         #endif
00226         #ifdef INCLUDE_set
00227             #include  <set.h>
00228         #endif
00229         #ifdef INCLUDE_stdexcept
00230             #include  <stdexcept.h>
00231         #endif
00232         #ifdef INCLUDE_string
00233             #include  <string.h>
00234         #endif
00235         #ifdef INCLUDE_vector
00236             #include  <vector.h>
00237         #endif
00238     #endif
00239 
00240     #if (__BORLANDC__ >  0x0410)  // Versiones posteriores a BC++ v3.1
00241         #define OPEN_namespace(N) namespace N {
00242         #define CLOSE_namespace(N) }
00243         #define USING_namespace(N) using namespace N
00244         #error Ajuste ADH_port.h para compìlar con versiones nuevas de BC++
00245     #endif
00246 #endif
00247 
00248 // Microsoft C++ (Visual Studio)
00249 #ifdef _MSC_VER                   ///< Definida para Micrsoft C++
00250     // namespace
00251     #define OPEN_namespace(N) namespace N {
00252     #define CLOSE_namespace(N) }
00253     #define USING_namespace(N) using namespace N
00254 
00255     #if (_MSC_VER >= 1300)        //   Identifica a VC++ .net
00256         /// Definido por la biblioteca C++ estándar
00257         namespace std {} // Está acá para que Doxygen lo documente
00258         using namespace std;
00259 
00260         #ifdef INCLUDE_fstream
00261             #include  <fstream>
00262         #endif
00263         #ifdef INCLUDE_io
00264             #include  <io>
00265         #endif
00266         #ifdef INCLUDE_iomanip
00267             #include  <iomanip>
00268         #endif
00269         #ifdef INCLUDE_iostream
00270             #include  <iostream>
00271         #endif
00272         #ifdef INCLUDE_list
00273             #include  <list>
00274         #endif
00275         #ifdef INCLUDE_map
00276             #include  <map>
00277         #endif
00278         #ifdef INCLUDE_set
00279             #include  <set>
00280         #endif
00281         #ifdef INCLUDE_stdexcept
00282             #include  <stdexcept>
00283         #endif
00284         #ifdef INCLUDE_string
00285             #include  <string>
00286         #endif
00287         #ifdef INCLUDE_vector
00288             #include  <vector>
00289         #endif
00290     #endif
00291 
00292     #if (_MSC_VER < 1300)         //   Identifica a VC++ v6 y anterior
00293         namespace std {} // Está acá para que Doxygen lo documente
00294         using namespace std;
00295         // Antes de MSC++ .NET hay que usar <.h>
00296         #ifdef INCLUDE_fstream
00297             #include  <fstream.h>
00298         #endif
00299         #ifdef INCLUDE_io
00300             #include  <io.h>
00301         #endif
00302         #ifdef INCLUDE_iomanip
00303             #include  <iomanip.h>
00304         #endif
00305         #ifdef INCLUDE_iostream
00306             #include  <iostream.h>
00307         #endif
00308         #ifdef INCLUDE_list
00309             #include  <list.h>
00310         #endif
00311         #ifdef INCLUDE_map
00312             #include  <map.h>
00313         #endif
00314         #ifdef INCLUDE_set
00315             #include  <set.h>
00316         #endif
00317         #ifdef INCLUDE_stdexcept
00318             #include  <stdexcept.h>
00319         #endif
00320         #ifdef INCLUDE_string
00321             #include  <string.h>
00322         #endif
00323         #ifdef INCLUDE_vector
00324             #include  <vector.h>
00325         #endif
00326     #endif
00327 #endif
00328 
00329 #endif // ADH_port_h
00330 
00331 // EOF: ADH_port.h