IRIX Base Documentation 2002 November

home *** CD-ROM | disk | FTP | other *** search

/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / relnotes / c++_eoe / ch4.z / ch4

Wrap

Text File | 2002-10-08 | 16.7 KB | 659 lines

- 1 - 7.3.1.3m C++ Compiler Execution Environment Release Notes - 2 - 4. _N_e_w__F_e_a_t_u_r_e_s 4.1 _N_e_w__F_e_a_t_u_r_e_s__i_n__M_I_P_S_p_r_o__7_._3_._1_._3_m This section lists the new C++ features for the MIPSpro 7.3.1.3m release. 4.1.1 _O_p_t_i_o_n__t_o__d_i_s_a_b_l_e__p_r_e_l_i_n_k_e_r__o_u_t_p_u_t A new flag, -quiet_prelink has been added which when added to the compilation command line will disable output of standard prelinker messages. This fixes bug #786921. 4.1.2 _E_x_p_e_r_i_m_e_n_t_a_l__v_e_r_s_i_o_n__o_f__n_e_w__F_r_o_n_t_-_E_n_d A new experimental version of the C++ front-end based on EDG version 2.45 and packaged as /usr/lib32/cmplrs/fecc_245 will be invoked when -Zf,_245 is added to the compilation command line. The new front-end supplies more ANSI/ISO compliant features. 4.1.3 _E_x_p_e_r_i_m_e_n_t_a_l__v_e_r_s_i_o_n_s__o_f__l_i_b_C_i_o___p_t_h_r_e_a_d_s_._a New experimental versions of libCio.a are being provided for use when compiling with the -D_PTHREADS attribute. There are n32 and 64-bit versions called /usr/lib32/libCio_pthreads.a and /usr/lib64/libCio_pthreads.a. To link with them you must explicitly refer to them on the compilation or linkage command line. 4.2 _N_e_w__F_e_a_t_u_r_e_s__i_n__M_I_P_S_p_r_o__7_._3 This section lists the new C++ features for the MIPSpro 7.3 release. 4.2.1 _T_e_m_p_l_a_t_e_-_R_e_l_a_t_e_d__f_e_a_t_u_r_e_s New C++ template-related features are described in the following sections. 4.2.1.1 _O_v_e_r_l_o_a_d_e_d__F_u_n_c_t_i_o_n__T_e_m_p_l_a_t_e_s The 2.38 front end now permits you to overload a function - 3 - template, as in the following example. template <class T> void f(T t); (1) template <class X> void f(X p*); (2) When you call an overloaded function template, the compiler selects the most specific version that matches the argument. If the function f is overloaded as in the previous example, the compiler selects version (1) when you write f(10) and it selects version (2) when you write f((double*) 0). (Previous versions of the compiler would issue an error in this case.) The C++ standard refers to this feature as "partial ordering of function templates." It is sometimes also called "partial specialization of functions." 4.2.1.2 _E_x_p_l_i_c_i_t _S_p_e_c_i_f_i_c_a_t_i_o_n _o_f _F_u_n_c_t_i_o_n _T_e_m_p_l_a_t_e _A_r_g_u_m_e_n_t_s The usual way of calling a function template is the same as calling an ordinary function. If you write f(10), for example, the compiler deduces the types of the template parameters. It is now also possible to specify the template arguments explicitly, as in f<int>(10). This feature makes it possible to write function templates whose template arguments cannot be deduced. For example: template <class T> inline T* null_pointer() { return (T*) 0; } It is impossible for the compiler to deduce the type of the template argument of null_pointer from the function's arguments because the function takes no arguments. You must explicitly provide the template arguments when you call this function, as in the following example: null_pointer<X>(). Previous versions of the compiler did not permit function templates with template arguments that could not be deduced. 4.2.1.3 _U_n_n_a_m_e_d__T_e_m_p_l_a_t_e__P_a_r_a_m_e_t_e_r_s Unnamed template parameters are now legal, as in the following example: template <class,int> struct A {}; A<char,1> a1; - 4 - 4.2.1.4 _N_e_w__S_y_n_t_a_x__f_o_r__R_e_f_e_r_r_i_n_g__t_o__T_e_m_p_l_a_t_e__M_e_m_b_e_r_s The C++ standard allows (and in some cases requires) a new syntax for referring to a member template of a class. If a class A has a member template B<T>, you can write A::template B<T>, or a.template B<T>, or pa->template B<T>. Example: struct X { template <class T> struct Y; template <class T> void f(); template <class T> void g(T); }; X x; X::template Y<int> y; x.template f<int>(); x.g(10); // No "template" keyword here, because we are // not providing g's template argument list. In this example, the new syntax is not required. It is required in only one specific case: when you are referring to a member template of a class that itself depends on a template parameter. Example: template <class T> void f(T t) { T::template Y<int> y; ... } The new syntax is required in this case because the compiler must be able to interpret "<" as the beginning of a template argument list or as a less-than operator. (Previous releases of the compiler neither required nor allowed the new syntax. This release allows it but does not require it. Future releases might require it.) 4.2.2 _N_e_w__C_o_m_p_i_l_e_r__C_o_m_m_a_n_d__L_i_n_e__O_p_t_i_o_n_s The following sections describe new compiler options for C++. - 5 - 4.2.2.1 _I_n_t_e_r_p_r_o_c_e_d_u_r_a_l__P_a_r_a_l_l_e_l_i_z_a_t_i_o_n The -ipa option invokes the Interprocedural Analyzer option group. This is a new alias for -IPA:=ON. Compiling with the -ipa and -pfa options together instructs the compiler to perform interprocedural parallelization. The compiler applies a sophisticated analysis to determine when it can parallelize loops with calls. 4.2.2.2 _L_i_s_t_i_n_g__C_o_n_t_r_o_l The -clist option invokes the listing control group. This is equivalent to -CLIST:=ON. The emit_omp=_f_l_a_g suboption to the -CLIST option directs the compiler to use OpenMP directives (_f_l_a_g=ON) or MIPS(TM) multiprocessing directives (_f_l_a_g=OFF). 4.2.2.3 _M_e_m_o_r_y__L_o_c_a_t_i_o_n The speculative_ptr_deref={ON/OFF} suboption to the -OPT compiler option allows speculative loads of memory locations that differ by a small offset from some referenced memory location. For more information, see the opt(5) man page. 4.2.2.4 _P_a_r_a_l_l_e_l_i_z_a_t_i_o_n__A_n_a_l_y_s_i_s The -LNO:pure={_f_l_a_g} option tells the compiler how to use the "no side effects" and "pure" pragmas when gathering information about calls for parallelization analysis. 4.2.2.5 _T_a_r_g_e_t__O_p_t_i_o_n__G_r_o_u_p__C_o_n_t_r_o_l_s The target option group has the following new controls: dismiss_mem_faults=_f_l_a_g Forces the kernel to dismiss memory faults that occur during execution. exc_max=_v_a_l_u_e Specifies the maximum set of IEEE- 754 floating point exceptions for which traps can be enabled at run time. exc_min=_v_a_l_u_e Specifies the minimum set of IEEE- 754 floating point exceptions for which traps must be enabled at run - 6 - time. isa=_v_a_l_u_e Identifies the target instruction set architecture for compilation. sync=_f_l_a_g Enables or disables the use of SYNC instructions. 4.2.2.6 _-_T_E_N_V__S_u_b_o_p_t_i_o_n The large_got=ON/OFF suboption to the -TENV compiler option replaces the -avoid_gp_overflow and the -xgot options. 4.2.3 _O_t_h_e_r__N_e_w__F_e_a_t_u_r_e_s The following sections describe other new C++ features. 4.2.3.1 _C_-_C_a_l_l_a_b_l_e__R_o_u_t_i_n_e_s C-callable versions of POPCNT, POPPAR, LEADZ, and MASK are now available. 4.2.3.2 _C_o_v_a_r_i_a_n_t__R_e_t_u_r_n__T_y_p_e_s Usually, when a derived class overrides a base class's virtual member function, the function in the derived class must have exactly the same signature as in the base class. There is, however, one small exception. If a virtual function in a base class returns a pointer (or reference) to a class X, the overriding virtual function can return a pointer to X or to some other class that inherits from X. Example: struct X { virtual ~X() {} virtual X* clone() const { return new X(*this); } }; struct Y : public X { virtual Y* clone() const { return new Y(*this); } }; Previous compiler releases did not permit covariant return types. They required a virtual member function in a derived - 7 - class to have exactly the same return type as in the base class. 4.2.3.3 _L_o_o_k_u_p _R_u_l_e_s _f_o_r _M_e_m_b_e_r _R_e_f_e_r_e_n_c_e_s _o_f _t_h_e _F_o_r_m _x._A::_B _a_n_d _p->_A::_B In a class member access expression like x.A::i or p->A::i, the class reference (in this case A) is looked up both in the context of the expression and in the context of the left operand of the "." or "->" operator (in this case, the class of which x is a member). Formerly, the class reference was looked up only in the first context, as in the following example: struct A { typedef A B; int i; }; int main() { A a; a.B:: i = 1; // not previously allowed } 4.2.3.4 _N_e_w__#_p_r_a_g_m_a The unknown_control_flow (_f_u_n_c_1 [, _f_u_n_c_2 ...]) #pragma indicates that the procedures listed as _f_u_n_c_1 and _f_u_n_c_2, etc. have a nonstandard control flow behavior. 4.2.3.5 _O_p_e_n_M_P__D_i_r_e_c_t_i_v_e_s__f_o_r__S_h_a_r_e_d__M_e_m_o_r_y__M_u_l_t_i_p_r_o_c_e_s_s_i_n_g OpenMP directives are based on the OpenMP C/C++ application programming interface (API) standard. Programs that use these directives are portable and can be compiled by other compilers that support the OpenMP standard. To enable recognition of the OpenMP directives, specify -mp on the cc or CC command line. Details of these directives are documented in the _M_I_P_S_p_r_o _C _a_n_d _C++ _P_r_a_g_m_a_s manual. 4.2.3.6 _O_v_e_r_l_o_a_d_i_n_g__o_n__E_n_u_m_e_r_a_t_i_o_n_s You cannot overload an operator if all of its arguments are - 8 - built-in types, but you can overload it if at least one argument is a class or enumeration type. Example: enum E {a, b, c, error}; E operator++ (E e) { switch(e) { case a: return b; case b: return c; case c: return a; default: return error; } } Previous compiler releases did not allow overloaded operators all of whose arguments were enumeration types. 4.2.3.7 _S_t_a_n_d_a_r_d__C_+_+__L_i_b_r_a_r_y A standard C++ library is now available. This library includes a standard-conforming I/O library, which has new header names. For example, the old iostream.h header is now iostream. The functionality for this feature is provided in libCio.so, which is provided for n32- and 64-bit ABIs. Using the new library requires including the -LANG:std option on the command line. The -LANG:std option also triggers the following ISO/ANSI standard-conforming behavior: +o A user-defined assignment operator for class X is a nonstatic nontemplate operator= with a single parameter of one of the following types: X X& const X& volatile X& const volatile X& A template operator= or an operator= with a different type (even if the type is derived from X) is not considered to be an assignment operator, and does not prevent the compiler from generating an implicit operator=. - 9 - +o The typename keyword cannot be omitted where the standard mandates it. +o The scope of a variable declared in the initialization of a for-loop is the for-loop and not the surrounding scope. +o Guiding declarations are not allowed. +o Old-style template specializations are not allowed. The new template syntax is now required for complete specializations. +o When you use -LANG:std, there is no longer an implicit conversion from function pointer types to void*. However, it is still possible to do the conversion with a cast. +o When you use -LANG:std, operator new throws a bad_alloc exception to signal out of memory, rather than returning a null pointer. +o The overload resolution rules are now stricter in the sense that some old tie-breaker rules have been abolished. The effect of this is that some function calls that were resolved by these discarded rules are now ambiguous. For example, consider the following code: struct X { X(int); }; void f(int, const int *); void f(X, int *); int main() { int *p; f(1, p); } If -LANG:std is specified, the call to f(1, p) becomes ambiguous. Because f(int, const int*) is preferred for the first argument but f(X, int *) is preferred for the second, no attempt is made to reconsider and break the tie. +o The _STANDARD_C_PLUS_PLUS macro is defined. - 10 - 4.2.3.8 _S_u_p_e_r_c_o_m_p_u_t_i_n_g__A_P_I__S_u_p_p_o_r_t The MIPSpro 7.3 release supports the Supercomputing Application Programming Interface (API), a set of language features and library functions that are implemented across the Silicon Graphics and Cray(TM) product line to meet the application portability needs of high-performance, technical computing customers.