Numeral: Fichero Fuente 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         #undef false
00185         #undef true
00186         #undef bool
00187 
00188         // Declara el tipo "bool" porque BC++ v3.1 NO tiene "bool"
00189         typedef int bool;
00190         const int false = 0;
00191         const int true  = ! false; // BC++ v3.1 NO tiene "bool"
00192 
00193         class istream; class ostream;
00194 
00195         #define using              // BC++ v3.1 NO tiene "namespace"
00196         #define namespace
00197         #define std
00198         #define ADH
00199 
00200         #define OPEN_namespace(N)  // BC++ v3.1 NO tiene "namespace"
00201         #define CLOSE_namespace(N)
00202         #define USING_namespace(N)
00203 
00204         #ifdef INCLUDE_fstream
00205             #include  <fstream.h>
00206         #endif
00207         #ifdef INCLUDE_io
00208             #include  <io.h>
00209         #endif
00210         #ifdef INCLUDE_iomanip
00211             #include  <iomanip.h>
00212         #endif
00213         #ifdef INCLUDE_iostream
00214             #include  <iostream.h>
00215         #endif
00216         #ifdef INCLUDE_list
00217             #include  <list.h>
00218         #endif
00219         #ifdef INCLUDE_map
00220             #include  <map.h>
00221         #endif
00222         #ifdef INCLUDE_set
00223             #include  <set.h>
00224         #endif
00225         #ifdef INCLUDE_stdexcept
00226             #include  <stdexcept.h>
00227         #endif
00228         #ifdef INCLUDE_string
00229             #include  <string.h>
00230         #endif
00231         #ifdef INCLUDE_vector
00232             #include  <vector.h>
00233         #endif
00234     #endif
00235 
00236     #if (__BORLANDC__ >  0x0410)  // Versiones posteriores a BC++ v3.1
00237         #define OPEN_namespace(N) namespace N {
00238         #define CLOSE_namespace(N) }
00239         #define USING_namespace(N) using namespace N
00240         #error Ajuste ADH_port.h para compìlar con versiones nuevas de BC++
00241     #endif
00242 #endif
00243 
00244 // Microsoft C++ (Visual Studio)
00245 #ifdef _MSC_VER                   ///< Definida para Micrsoft C++
00246     // namespace
00247     #define OPEN_namespace(N) namespace N {
00248     #define CLOSE_namespace(N) }
00249     #define USING_namespace(N) using namespace N
00250 
00251     #if (_MSC_VER >= 1300)        //   Identifica a VC++ .net
00252         /// Definido por la biblioteca C++ estándar
00253         namespace std {} // Está acá para que Doxygen lo documente
00254         using namespace std;
00255 
00256         #ifdef INCLUDE_fstream
00257             #include  <fstream>
00258         #endif
00259         #ifdef INCLUDE_io
00260             #include  <io>
00261         #endif
00262         #ifdef INCLUDE_iomanip
00263             #include  <iomanip>
00264         #endif
00265         #ifdef INCLUDE_iostream
00266             #include  <iostream>
00267         #endif
00268         #ifdef INCLUDE_list
00269             #include  <list>
00270         #endif
00271         #ifdef INCLUDE_map
00272             #include  <map>
00273         #endif
00274         #ifdef INCLUDE_set
00275             #include  <set>
00276         #endif
00277         #ifdef INCLUDE_stdexcept
00278             #include  <stdexcept>
00279         #endif
00280         #ifdef INCLUDE_string
00281             #include  <string>
00282         #endif
00283         #ifdef INCLUDE_vector
00284             #include  <vector>
00285         #endif
00286     #endif
00287 
00288     #if (_MSC_VER < 1300)         //   Identifica a VC++ v6 y anterior
00289         namespace std {} // Está acá para que Doxygen lo documente
00290         using namespace std;
00291         // Antes de MSC++ .NET hay que usar <.h>
00292         #ifdef INCLUDE_fstream
00293             #include  <fstream.h>
00294         #endif
00295         #ifdef INCLUDE_io
00296             #include  <io.h>
00297         #endif
00298         #ifdef INCLUDE_iomanip
00299             #include  <iomanip.h>
00300         #endif
00301         #ifdef INCLUDE_iostream
00302             #include  <iostream.h>
00303         #endif
00304         #ifdef INCLUDE_list
00305             #include  <list.h>
00306         #endif
00307         #ifdef INCLUDE_map
00308             #include  <map.h>
00309         #endif
00310         #ifdef INCLUDE_set
00311             #include  <set.h>
00312         #endif
00313         #ifdef INCLUDE_stdexcept
00314             #include  <stdexcept.h>
00315         #endif
00316         #ifdef INCLUDE_string
00317             #include  <string.h>
00318         #endif
00319         #ifdef INCLUDE_vector
00320             #include  <vector.h>
00321         #endif
00322     #endif
00323 #endif
00324 
00325 #endif // ADH_port_h
00326 
00327 // EOF: ADH_port.h