                                                    : 2004 ǯ 5  27 

Sun[tm] Studio 9: C++ FAQ

    ܼ

        A.Υ꡼ɲä줿
        B.С󡢥ѥåӥݡ
        C.ѥθߴ
        D.ǥ󥰤ӿ
        E.饤֥θߴ
        F.ѥΥѥեޥ󥹤θ
        G.¹ԻΥѥեޥ󥹤θ

    ------------------------------------------------------------------

    A.Υ꡼ɲä줿

      1.줾Υ꡼ǡɤΤ褦 C++ ѥǤ뤫ǧ
        뿮Ǥˡ򶵤Ƥ
  
      2.Ƕ Solaris OS ˥ѥå򥤥󥹥ȡ뤷ΤǤɤ
        ѥ뤵ʤʤޤɤƤǤ?
  
      3.foo.cc եΥѥ롢ޤ¾ΥλȤΤ
        ԤäƤʤˤ⤫餺foo.cc ˴ؤ륨顼ٹ
        Ϥޤ򶵤Ƥ
  
      4.-P ץѤơˤä줿 foo.i ե
        򥳥ѥ뤹ȡʣƤ뤳Ȥ򼨤顼
        ֤ޤ򶵤Ƥ
  
      5.C++ ѥΥץꥳѥѤߥإåե뵡ǽȤ
        ᤿ΤǤѥΥѥեޥ󥹤夷ޤ󡣤ɤ
        ƤǤ?
  
      6.ʥե٤ơ礭ʥեΥѥˤ
        ĹޤɤƤǤ?
  
      7.SPARC V9 ֥饤֥ưŪ饤֥˥󥯤ȡ
        顼ˤʤޤɤƤǤ?Sun Studio 8 Ǥꤢ
        Ǥ
  
      8.SunWS_cache: Error: Lock attempt failed for SunWS_cacheפ
        å֤븶򶵤Ƥ
  
      9.ɸ饤֥ꥹȥ꡼बgcc  KAI ȥ꡼®Ǥ
        ѥեޥ󥹤㲼礭ޤϤΤǤ礦 ?
  
     10.󥫡ld: warning: symbol 'clog' has differing types
        Ȥٹ֤ޤɤƤǤ?
  
     11.-xarch=v8plus ޤ -xarch=v8plusa դƥѥ뤹ȡ
        STLport Ѥޥåɥץबå夷ޤ
        ɤƤǤ礦?
  
     12.abs() ФƤӽФޤǤȤ̣Υå
        ѥ餫֤ޤɤƤǤ?
  
     13.֥ȤϤ˲ΤǤ礦? 


    ------------------------------------------------------------------

      1.줾Υ꡼ǡɤΤ褦 C++ ѥǤ뤫ǧ
        뿮Ǥˡ򶵤Ƥ 

        ɤΥѥˤ⡢Ȥξ󶡤뤤ĤΥޥ
        ƤޤѥΥ٥ϡ꡼Ѥä
        ⡢ޥꤷư褦ˤϤ
        ƤꡢSun ξϡꤷ󥿥եȤ
        ޤ
        
        ΥѥǧˡȤɤΤϡޥ
        ̵ͭǧơӤ˹äʸϤ뾮ʥץ
        뤳ȤǤץ-E (ޤϡ¾
        ѥξ륪ץ) դƤΥץ
        ѥ뤹뤳ȤǤޤ
        
        C++ ѥλޥˤĤƤϡC++ 桼
        ɡ٤κΡ֥ޥפ򻲾ȤƤŪˤϡ
        __SUNPRO_CC ͤ 3  16 ʿǤǽο᥸㡼
        ꡼2 ܤοޥʡ꡼3 ܤοޥ
        ꡼ɽޤȤ C++ 5.6  0x560 Ǥ 
        
        ʲ˼ʻޥƤ򼨤ޤ 
         
        #ifdef __sun
               Sun compiler
        #endif
        #ifdef __SUNPRO_C
               Sun C compiler /* __SUNPRO_C ͤϥСֹ */
        #endif
        #ifdef __SUNPRO_CC
               Sun C compiler /* __SUNPRO_CC ͤϥСֹ */
        #endif
        #ifdef __sparc
               generate code for SPARC architecture
        #endif
        #ifdef __sparcv9
               generate code for 64-bit SPARC architecture
        #endif
        #ifdef __i386
               generate code for Intel architecture
        #endif
        
      2.Ƕ Solaris OS ˥ѥåƤΤǤɤѥ뤵
        ʤʤޤɤƤǤ? 
        
        ǶΥС Solaris 󶡤Ƥ뿷شؿ
        ǡǤäɤˤʤäǽޤ
        
         <math.h> δؿϤ٤double ѤΥСǤ
         Solaris إåӥ饤֥ˤϡfloat  
        long double ¿⤢ޤޤʸƤӽФ
        뤿ᡢΰĴؿθƤӽФǡŪʥ㥹Ȥ
        ɲäɬפˤʤ뤳Ȥޤʲ򼨤ޤ
        
        #include <math.h>
        extern int x;
        double      z1 = sin(x); // ߤϤޤ
        double      z2 = sin( (double)x ); // OK
        float       z3 = sin( (float)x ); // OK
        long double z4 = sin( (long double)x ); //  OK
        
         Solaris ѥåϡSolaris 8  9 Ѥ libm ѥå
        ¸Ƥ ANSI C++ ˽򤷤 <cmath>  <math.h> 
        ֥ꥵݡȤ󶡤ޤ 
        
        Solaris 9 SPARC (ѥå 111722-04) 
        Solaris 9 i386 (ѥå 111728-03) 
        Solaris 8 SPARC (ѥå 111721-04) 
        Solaris 8 i386 (ѥå 112757-01) 
        
      3.foo.cc եΥѥ롢ޤ¾ΥλȤΤ
        ԤäƤʤˤ⤫餺foo.cc ˴ؤ륨顼ٹ
        Ϥޤ򶵤Ƥ 
        
        إåե foo.h ˥ƥץ졼硢ǥե
        ȤǤϥѥϡC++ ΥեĥҤĥե foo 
        (foo.cfoo.ccfoo.Cfoo.cppfoo.c++) õĤä
        ϡưŪˤΥեߤޤܺ٤ϡC++ 桼
        ɡ٤ΡTemplate Definitions Searchingפ򻲾ȤƤ
        
        
        ե foo.cc 򤳤Τ褦˽ʤ硢 2 
        ޤ
        
           o .h ޤ .cc ե̾ѹơоݤӽ
             褦ˤ롣 
           o -template=no%extdef ץꤹ뤳Ȥˤäơ
             ƥץ졼եμư̵ˤ롣
             顢ΥץϡΩƥץ졼θ
             ٤̵ˤޤC++ ɸΥ饤֥Ǥϡ
             餬Ω򸡽ФΤꤷƤޤΤ
             ᡢ٤ƤΥƥץ졼Ū˼ɬפꡢ
             ʤΩǥѤǤޤ
        
             ƥץ졼ǥΤ˾ܤƤϡC++ 桼
             ɡ٤ 5.2.1  5.2.2 򻲾ȤƤ
             C++ 桼ɡ٤κˡΩǥ뤪
             ߥǥƤ꤬ܤƤޤ
        
      4.-P ץѤơˤä줿 foo.i ե
        򥳥ѥ뤹ȡʣƤ뤳Ȥ򼨤顼
        ֤ޤ򶵤Ƥ 
        
        ǥեȤǤϡѥϡƥץ졼ȤʬΥ
        Ƥ뤳Ȥǧޤƥץ졼ǥΤ˾ܤ
        ƤϡC++ 桼ɡ٤ 5.2.1  5.2.2 򻲾
        ƤC++ 桼ɡ٤κˡΩǥ
        ߥǥƤ꤬ܤƤޤ
        
        ɬפʥƥץ졼Ȥʤ .h ޤ .i եˤ
        ȡѥϥƥץ졼եõޤ.h ޤ
         .i ե̾ƱǡĥҤ c  ccCc++cpp 
        줫Υեƥץ졼եȤߤʤޤC++ 
        ˥奢Ƥ褦ˡե뤬¸ߤȡ
        ưŪ˼ޤޤ
        
        foo.cc ե뤬 -P դƥѥ뤵ơfoo.i 
        졢ɬפʥƥץ졼ȤϤ뤬ʤȲꤷޤ
        ѥեõfoo.cc 򸡽Фޤfoo.cc 
        ե뤬ưŪ˼ޤ졢ʣ뤳Ȥˤʤޤ
        
        ѥΥƥץ졼θϡ-template=no%extdef 
        ꤹ뤳Ȥˤä̵ˤǤޤʤ顢
        ץϡΩƥץ졼θ⤹٤̵ˤ
        C++ ɸΥ饤֥Ǥϡѥ餬Ω
        ФΤꤷƤޤ
        
        ξϡ.i ե򥳥ѥ뤷櫓Ǥ顢ñ
        ե̾ѹơդ̾ˤޤΩƥץ졼
        Υѥ̵ˤɬפϤޤ󡣰ʲ򼨤ޤ
        
                CC -P foo.cc
                mv foo.i foo_prep.i
                CC -c foo_prep.i
        
        -E ץѤơѤߥե硢
        ˡϵǽʤȤդƤ-E ץϼ
        ޤ줿ե̾εϿȤ뤿ᡢ³ .cc ե
        ưŪ˸Фǽޤ
        
      5.C++ ѥΥץꥳѥѤߥإåե뵡ǽȤ
        ᤿ΤǤѥΥѥեޥ󥹤夷ޤ󡣤ɤ
        ƤǤ? 
        
        ץꥳѥѤߥإåȤȤˤäơѥ֤
        ṳ̂ݾڤϤޤ󡣥ץꥳѥѤߥإåѤ
        ȡեľܥѥ뤷ȤˤϤʤСإåɤ
        ¿ޤѥեޥ󥹤θΤˤϡץꥳѥ
        ¿ξĹץꥳѥѤߥإå¸ߤɬ
        פޤ
        
        ȤСץꥳѥ뤹뤳ȤǥåȤǽ
        ץȤƤϡ¿Υƥإåϥȥ꡼ࡢ
        STL إåץȥإåޤǤץब
        ޤեˤϡդѥ륳ɤޤޤ
        뤿ǤΥإåʣޤ뤿ᡢե
        Τ if Τ򥹥󤷤СĹʥ󥯥롼ɤǹԤ
        뤳ȤϲʤȤ狼ޤ̤ˡƥإå
        ϿɴĤΥޥޤ
        
        ץꥳѥѤߥإåѤȤȤϡΥե
        򳫤 1 ĤΥե򳫤Ȥ̣ޤ
        Ȥ;ʬʶƱ褦ˤơ⤷ʤʣΥ󥯥롼ɤ
        ޤإåΥޥϻŸޤ̤ˡ
        Ȥѥ֤ṳ̂ˤĤʤޤ
        
      6.ʥե٤ơ礭ʥեΥѥˤ
        ĹޤɤƤǤ? 
        
        餯ϥեΥǤϤޤ󡣹ͤ븶
        3 Ĥޤ
        
           o եδؿΥȺŬ٥
             
             Ŭ٤ι⤤礭ʴؿϽ˻֤ꡢ̤Υ
             ꡼ɬפȤ뤳ȤޤɤǹϰϤ礭ʥ
             ѤƤ硢ؿޥŸ
             礭ʤ뤳Ȥޤ
             
             Ŭʤ (-xO?  -O? ץդʤ) ǥѥ
             뤷ƤߤƤѥ뤬û֤˽λ硢
             餯ϡ礭ʴؿե 1 İʾ¸ߤ
             ƤơŬˤʤλ֤ȥ꡼פ뤳Ȥˤ
             ޤ
             
             ޤѥ˻Ѥԥ塼ˡѥ
             ԤΤ˽ʬʪ꡼뤳ȤǧƤ
             ʬʥ꡼ʤȡŬեǻ֤뤳
             ޤ
             
           o 饤ؿ
             
             C  C++ Υ饤ؿϥޥ˻Ƥơѥ
             ֤˱ƶͿޤؿƤӽФ򥤥饤Ÿ
             ȡ̤ΥɤѴ뤳Ȥޤѥ
             ϡ2 İʾξʴؿǤϤʤ 1 礭ʴؿн褹
             Ȥˤʤޤ
             
             ؿΥ饤󲽤̵ˤȡѥ֤ṳ̂
             뤳ȤФФޤΤȤȤơƤ
             硢륳ɤμ¹®٤㲼ޤ
             
             ܺ٤ϡC++ 桼ɡ٤ -xinline ӡUsing
             Inline Functionsפ򻲾ȤƤ 
             
           o C++ Υ饹ƥץ졼
             
             C++ ƥץ졼ȤꤵƤ硢ѥϸƤӽ
             줿ƥץ졼Ȥ˴Ťƥɤޤ1 Ԥ
             ɤФơ1 İʾΥƥץ졼ȴؿ
             ɬפˤʤ뤳ȤޤĤޤꡢƥץ졼ȤΤΤ
             ѥ®٤㲼ƤΤǤϤʤΥ
             ɤθܤ⥳ѥ餬ʤФʤʤ
             ɤ¿ȤȤǤ
             
             ȤСʲΤ褦ʴؿ򤹤Ǥ˴ޤɸ饤֥꤬
             äȲꤹȡɤΤιԤϡ241 Ĥ
             ؿ뤳Ȥˤʤޤ
             
             cout << "value = " << x << endl;
        
      7.SPARC V9 ֥饤֥ưŪ饤֥˥󥯤ȡ
        顼ˤʤޤɤƤǤ?Sun Studio 8 Ǥꤢޤ
        Ǥ 
        
        V9 ѤοǥեȤΥѥ饢ɥ쥹ɥǥϡ
        -xcode=abs44 Ǥϡ -xcode=abs64 ٤ƥѥե
        ޥ󥹤夵ޤʤ顢οɥǥϡ
        ưŪ饤֥ǤϻѤǤޤ󡣤Ф 2
        Ĥޤ
        
           o -xcode=pic13 ޤ -xcode=32 դƥ֥ȥե
             ƥѥ뤹롣ˡ侩ޤۤܤĤǤ⡢
             ŬڤʲǤ
        
           o -xcode=abs64 դƥ֥ȥեƥѥ뤹
             롣ˡǤϡưŪ饤֥꤬ͭǤʤʤޤ
             ̤Υ꡼ΰ˥ԡȤˡץȤ˥饤
             񤭴ɬפޤˡϡѥեޥ
             礭ƥඦͭΨ㤤ﲼĹ
             ּ¹Ԥ륢ץꥱФͭѤǤ
        
      8.SunWS_cache: Error: Lock attempt failed for SunWS_cacheפ
        å֤븶򶵤Ƥ 
        
        ƥץ졼ȥå˴ؤơlock attempt failedפȤ
        顼å֤ʸ 2 Ĥޤ
        
           o åФݻƤåʤ
             ѥ뤬۾ｪλ뤫λ뤿ξ
             ϡŤСΥѥȯ뤳Ȥޤ
             С󤪤ӺǿΥѥåƤ줿Ť
             Ǥϡѥνλˡ˴طʤɬå
             褦ˤʤäƤޤñ˥åեƤ
             ޤޤ󤬡Ƥå夬Ƥ뤿ᡢ
             ȡ꤬ޤǤˡϡƥ
             졼ȥåΤ뤳ȤǤ
        
           o ѥץƥץ졼ȥå˽񤭹ߤ
             ʤܺ٤ϡumask(1) Υޥ˥奢ڡ򻲾ȤƤ
             Ūˤϡ˥åޤϥե
             ץ umask ǡƱå˥ɬפ
             ¾Υץˤ륭åؤν񤭹ߤĤƤ
             ɬפޤǥ쥯ȥ꤬ NFS ե륷ƥ˥
             ȤƤϡƥɤ߼/񤭹ߥޥ
             Ȥɬפޤ 
        
      9.ɸ饤֥ꥹȥ꡼बgcc  KAI ȥ꡼®Ǥ
        ѥեޥ󥹤㲼礭ޤϤΤǤ礦 ?
        
        褹ˤϡ󥯻˿ C++ ѥ饪
         -sync_stdio=no ꤹ뤫sync_with_stdio(false) 
        ؿؤθƤӽФɲäơƥѥ뤷ޤ
        
        stdlib 2.1.1 Υѥեޥ󥹾κϡǥեȤ C 
        stdio  C++ ȥ꡼ƱȤ뤳ȤǤcout ؤΤ
        Ϥ٤˥եå夵ޤץब 
        stdout ǤϤʤ cout ̤νϤԤȡβ٤ΥХåե
        եåˤäơץμ¹ԻΥѥեޥ󥹤礭
        ƶ뤳ȤޤC++ ʤǤϡưɬפȤ
        Ƥޤɬ⤹٤ƤμλͤƤ櫓
        Ϥޤ󡣼ΥץϡƱȤʤ꤬ȯ
        ζǤΥץ˲ԤդHello 
        beautiful worldפȤԤϤΤǤ 
        
            #include <iostream>
            #include <stdio.h>
            int main()
            {
                std::cout << "Hello ";
                printf("beautiful ");
                std::cout << "world";
                printf("\n");
            }
        
        cout  stdout ΩƥХåե󥰤Ƥ
        硢ΥץϴԤ줿ϤԤʤǽޤ
        
        ¹ԲǽեƥѥǤʤϡ󥯻˿
        C++ ѥ饪ץ -sync_stdio=no ꤷƤ
        ΥץϡץϤȯΥץ
         sync_with_stdio( ) ƤӽФޤ
        
        ƥѥǽʾϡץϤ 
        sync_with_stdio(false) ФƤӽФɲä뤳Ȥˤäơ
        ϤƱȤɬפʤȤؼޤʲϡƤӽФ
        Ǥ
        
                #include <iostream>
                int main(int argc, char** argv)
                {
                        std::ios::sync_with_stdio(false);
                }
        
        sync_with_stdio ФƤӽФϡץκǽθƤӽФ
        ˤޤ
        
        -sync_stdio ξܺ٤ϡC++ 桼ɡ٤ޤ C++ 
        ˥奢ڡ CC(1) 򻲾ȤƤ
        
     10.󥫡ld: warning: symbol 'clog' has differing types
        Ȥٹ֤ޤɤƤǤ? 
        
        Ʊץ libm.so.2 ȵ켰ϥȥ꡼饤֥
        ꤬󥯤ȡ󥫡ϡۤʤμ夤ܥΥڥ
        뤳Ȥٹ𤷤ޤηٹ̵뤷Ƥޤޤ
        
        Solaris 10 ǤϡǥեȤοإ饤֥ libm.so.2 ǡ
        C99 ʤǵƤ褦ˡΥ饤֥̾
        ˤϡclogפȤʣǿпؿޤޤƤޤФ
        -compat=4 ޤ -library=iostream ꤹ뤳Ȥˤä C++ 
        ε켰ϥȥ꡼Ѥȡ֤̾˥Хåե
        դɸϥȥ꡼ΡclogפѤޤ(ɸϥ
        ȥ꡼ˤϡ̷⤹륷ܥϤޤ) 
        
        إåӥ饤֥꤬ĴơΡclogץܥ
        Ϥ줾ۤ̾ѹ뤿ᡢ1 ĤΥץǤξ
        ѤǤޤΥܥõŤХʥ꤬
        ³󥯤Ǥ褦ˤˤϡ饤֥Τ줾Ǹ
        ΥܥΥڥ夤ܥȤݻɬפޤ
        
        Τᡢϥȥ꡼ȿإ饤֥Ѥ
        ˤˤϡΥƥƥʬΤǤϤʤ
        Ŭڤʥƥإå򥤥󥯥롼ɤޤ
        
     11.-xarch=v8plus ޤ -xarch=v8plusa դƥѥ뤹ȡ
        STLport Ѥޥåɥץबå夷ޤ
        ɤƤǤ礦? 
        
        STLport ˤϡ-xarch=v8plus ޤ -xarch=v8plusa դ
        ƥѥ뤷Ȥޥåư˸Х
        ޤΥХϽƤޤνˤ STLport 
        إåѹȡĤ STLport ֥Ȥѹޤ
        ƤޤΥС STLport إåȤäƥ
        뤷ɤϡץ˥󥯤 C++ 5.6 
        ѥåƤΥ꡼Ǻƥѥ뤹ɬפޤ
        
     12.abs() ФƤӽФޤǤȤ̣Υå
        ѥ餫֤ޤɤƤǤ? 
        
        C++ ʤ 26.5 Ǥϡabs ؿ򼡤Τ褦¿뤳Ȥ
        Ƥޤ
        
           o <stdlib.h>  <cstdlib> 

             int  abs(int);
             long abs(long);
             
           o <math.h>  <cmath> 

             float       abs(float);
             double      abs(double);
             long double abs(long double);
        
        ʤǶޤǡSolaris ǻѤǤ abs Ͻ int Ǥ
        ǤɤΤ褦ʿͷ abs ƤӽФƤ⡢ͤϡ
        <stdlib.h> ޤ <cstdlib> 󥯥롼ɤƤΤȤơ
        ۤint Ѵ졢int Ǥ abs ƤӽФޤ 
        
        ǶιˤäơSolaris إåӥ饤֥ C++ 
        شؿ˴ؤ ʤ˽򤷤ΤˤʤäƤޤ
        
        ȤС<stdlib.h> ǤϤʤ<math.h> 򥤥󥯥롼ɤơ
        ΰ abs ƤӽФ硢ѥϡ3 Ĥư
        С abs ؿΤ 1 Ĥ򤹤ɬפ
        ޤͤǤդưѹǤ¾ͥ褹Ѵ
        ޤ(: C++  13.3.3 )ΤᡢδؿƤӽ
        ϤޤˤʤޤĤޤꡢޤ顼ϡC++ ʤ˽
        򤷤Ƥ륳ѥǤСɤǤ֤ޤ
        
        ΰ abs ؿƤӽФ硢ŬڤѤ
        褦ˤˤϡɸإå <stdlib.h> ޤ <cstdlib>
        򥤥󥯥롼ɤޤưͤ abs ƤӽФϡ
        <math.h> ޤ <cmath> ⥤󥯥롼ɤޤ
        
        ñʥץߥ󥰤νȤơ<math.h>  <cmath> 򥤥
        롼ɤϡ<stdlib.h> ޤ <cstdlib> ⥤󥯥롼ɤ
        뤳Ȥ侩ޤ
        
        ƱͤΤȤϡcos  sqrt ʤɤ¾οشؿˤƤϤޤޤ
        ߤ Solaris Υإåӥ饤֥ C++ ʤ˽򤷤
        ꡢؿ floatdouble long double ¿
        С󶡤ƤޤȤͤ sqrt Ƥ
        Ф硢äƤ 1 ĤΥС sqrt ʤäᡢ
        ѥ뤬ԤƤޤߤ 3 Ĥư
        С󤬤뤿ᡢͤŪư˥㥹Ȥ
        ɬפޤ 
        
                double root_2 = sqrt(2); // 顼
                double root_2 = sqrt(2.0); // OK
                double x = sqrt(int_value); // 顼
                double x = sqrt(double(int_value)); // OK
        
     13.֥ȤϤ˲ΤǤ礦? 
        
        ѥ餬֥ȤͳȤƤϡصΤ
        Ȥ⤢С쵬§ǤΤȤƤƤ뤿ΤȤ⤢
        ޤȤдؿ֤ͤϰ֥ȤǡѴη
        ֥ȤǤ
        
        ꥸʥ C++ ε§Ǥϡ֥ ("temp") ϡ
        줬줿֥åޤǤδ֤ˤĤǤ˲뤳Ȥ
        Ǥޤ C++ ѥϡ֥åν (Ĥ
        뱦)  temp ˲ޤ
        
        ǯˤ錄㤷ƤĤθ塢C++ Ѱϡtemp ˲٤
        ֤ˤĤƷãޤϡtemp 줿Τ
        ֤Ǥ̾ΰ֤ϡμʸ
        Ǥ줬C++ ʤε§Ǥ
        
        ʤ顢Sun  C++ ѤƤ¿Υץब
        餯̵ռΤˡ֥åνޤ temp ĤäƤ뤳
        Ȥ˰¸Ƥͽۤ뤿ᡢѥΥǥեȤư
        ѹƤޤ󡣤ʤǥեȤǤϡ֥
        ȤϺ줿֥åνΰ֤˲ޤ
        
        ʤ˽򤷤ư (temp 줿˽֤Ǥ
         temp ˲) ɬפʾϡѥץ 
        -features=tmplife ѤƤ
        
        ץΤ̤ƤΥץѤɬפϤޤ
        ⥸塼Ǻ줿֥ȤϡѥˤΥ
        ץͭɤ˽äơΥ⥸塼μ
        ֤ޤϥ֥å֤˲ޤ


    ------------------------------------------------------------------

    B. С󡢥ѥåӥݡ

      1.ɸפӡֵ켰ϥȥ꡼ΰ㤤ϤʤǤ ? 
        ޤ˴ؤ뻲ʸ򶵤Ƥ 

      2.ɤ C++ ѥ˸ߴΤʬˡ򶵤Ƥ
         

      3.Sun Studio 9 ǻѤǤ饤֥Ȥơǧפ 
        RogueWave 饤֥򶵤Ƥ 

      4.ɤΤ褦ʥѥåäơߤΥѥåǤɤΤ褦꤬褵
        ΤĴ٤ˤϡɤФ褤Ǥ礦 ? 

      5.libC.so.5  libCrun.so.1 ФѥåɬפǤ礦 ?


    ------------------------------------------------------------------

      1.ɸϥȥ꡼ȵ켰ϥȥ꡼ΰ㤤ϤʤǤ ?
        ޤ˴ؤ뻲ʸ򶵤Ƥ 

        2 ĤΥ饤֥ȼޤäۤʤޤ ñ
        ϤΥץߥ󥰥󥿥եϹƤޤ 
        桼ȼΥȥ꡼९饹ޥ˥ԥ졼ν񤭹ߤʤɡ
        ʣưˤĤƤ礭ۤʤޤ

        ܥСΡֵ켰ϥȥ꡼饤֥ϡ C++ 3.x 
         4.x °СȸߴޤΥ꡼
        °ޥ˥奢Τۤˤ⡢Τ褦ʻʸޤ

          o Steve Teale 
            C++ IOStreams Handbook 
            Addison-Wesley 1993 

        ɸϥȥ꡼饤֥ˤĤƤϡC++ Standard 
        Ƥޤ ¾ˤ⡢Τ褦ʻʸޤ 

          o Nicolai Josuttis 
            The C++ Standard Library 
            Addison-Wesley 1999 
            (C++ ɸ饤֥̤˴ؤ塼ȥꥢ) 

          o Angelika Langer  Klaus Kreft 
            Standard C++ IOStreams and Locales 
            Addison-Wesley 1999 
            (ϥȥ꡼ȥ˴ؤ塼ȥꥢ) 

        ñϤ뤿Υɤϡɤϥ
        ꡼̤äƤޤ ñ˰ܹԤ뤿ˡʳΥإ
         <iostream.h><fstream.h> <strstream.h> ɸ
        ϥȥ꡼Ƥޤ Υإåϡ켰
        ϥȥ꡼ˤ륰Х͡ॹڡȹ
        åȤ󶡤ޤΥإåѤȡǥեȤ
        ɸϥȥ꡼बѤޤ켰ϥȥ꡼ब
        Ѥ褦ˤˤϡ-library=iostream դƥѥ뤪
        ӥ󥯤Ԥޤ

        ȤСΥɤϡSun ΥѥѤƵ켰ɸ
        ξϥȥ꡼ǵǽޤΥѥ
        Ѥޤ 

        #include <iostream.h>

        class myclass {
        public:
                myclass(int i) : k(i) { }
                friend ostream& operator<<(ostream&,; const myclass&);
        private:
                int k;
        };

        // 桼ȼνϱ黻
        ostream& operator<<(ostream& os, const myclass& m)
        {
            os << m.k;
            return os;
        }

        int main()
        {
            // cout cin Ѥñ
            cout << "Enter a number: " << endl;
            int val;
            if( ! (cin >> val) ) {
                cout << "Invalid entry, using zero" << endl;
                val = 0;
            }

            // 桼ȼνϱ黻Ҥ
            myclass m(val);
            cout << "Value is " << m endl;
        }

        Τ줫ˡ Sun ѥѤơΥɤ
        ѥ롢¹Ԥޤ

        example% CC example.cc  # ɸ⡼ɤɸϥȥ꡼
        example% CC -library=iostream example.cc  # ɸ⡼ɤǵ켰ϥȥ꡼
        example% CC -compat=4 example.cc  # C++ 4.2 ߴ⡼


      2.C++ ѥΥС֤θߴϤɤΤ褦ˤʤäƤޤ
         ? 

        ޤƤޤ ־ߴפȤϡԥС
        ѥǥѥ뤵줿֥ȥɤ³С
        Υѥǥѥ뤵줿ɤȥ󥯤Ǥ뤳Ȥ̣
        ޤξ硢ǽ󥯤ǺǿΥѥѤɬפ
        ޤ

        C++ 4.04.1 4.2 ѥϾߴޤ 
        (C++ 4.2 ޥ˥奢˵ҤƤ褦ˡѥΥС
        ֤ˤĤΡ̾沽꤬ޤ)

        C++ ΥС 5.0 - 5.6 ޤǤΥѥϡߴ⡼ 
        (-compat) ǡ4.2 ѥȾߴǤC++ 4.2 ȥС
         5.0 - 5.6 줿ºݤΥ֥ȥɤȤϴ
        ˸ߴޤ³ѥ餬ȯǥХå (
        ) ԥǥХåȸߴޤ

        ǥեɸ⡼ɤǤϡC++  5.0 - 5.6 ޤǤΥѥ
        ߴޤ ºݤΥ֥ȥɤϴ˸ߴ
        ޤ³ѥȯǥХå () 
        ԥǥХåȸߴޤ

      3.Sun Studio 9 ǻѤǤ饤֥Ȥơǧפ 
        RogueWave 饤֥򶵤Ƥ 

        Sun ΥѥγƥСѤˡɤΥ٥ɤʤ
        ڤƤΤμ¤פ뤳ȤϤǤޤ ơ
        FAQ ˺ǿ˰ݻΤ⡢Ȥ񤷤֤Ǥ C++ 
        ѥСˤĤƥ٥ʥƥȤԤʤ
        ɤˤĤƤϡΥ٥䤤碌ɬפޤ

        Sun Υѥ°Ƥ RogueWave 饤
        ˤĤƤϡв٥Сȸߴ뤳Ȥۤݾڤ
        ޤ

      4.ɤΤ褦ʥѥåäơߤΥѥåǤɤΤ褦꤬褵
        ΤĴ٤ˤϡɤФ褤Ǥ礦 ? 

        ʥѥåκǿˤĤƤϡȯԸμΥݡ륵
        򤴳ǧ
        http://developers.sun.com/prodtech/cc

        ʤΥѥå http://sunsolve.sun.com ɤǤ
        

      5.libC.so.5  libCrun.so.1 ФѥåɬפǤ礦 ?

        ѥϡΥ꡼դˤƺǿ SUNWlibC ѥå
        Ȥ˽в٤ޤ

        ̤ˡSolaris[tm] ڥ졼ƥ󥰥ƥˤϡΥ饤
        ֥κǿǤ°Ƥޤ ФСΥ
        ֥ˤϡХνѥեޥ󥹤βɤΤΥѥå
        󶡤ޤ ѥåϾѤƤơ˸
        Ǥ뤿ᡢ󶡤ƤǤǿΥѥåѤ뤳Ȥ
        侩ޤ ɽϡ2002 ǯ 3 ߤκǿΥѥå ID 
        Ƥޤ

        ǡ١˺ǿΥѥå뤫ǧƤ ѥ
        ̾ SUNWlibC (32 ӥå) ޤ SUNWlibCx (64 ӥ
        ) Ǥ

                    ɽ 1 libC  libCrun Υѥå

            ѥå ID              Solaris             ƥ
                            ڥ졼ƥ󥰥ƥ

            108434-17                 8                SPARC/v8

            108435-17                 8                SPARC/v9

            108436-15                 8                x86

            111711-11                 9                SPARC/v8

            111712-11                 9                SPARC/v9

            111713-08                 9                x86


    C. ѥθߴ

      1.ߴ⡼ (-compat) Υɤɸ⡼ɤΥɤ򺮺ߤ
        ȤϤǤޤ ? 

      2.C++ ޤ C ץ F77F90ޤ F95 ץ
        ߹碌ˤϡɤФ褤Ǥ礦 ? 

    ------------------------------------------------------------------

      1.ߴ⡼ (-compat) ɸ⡼ɤΥɤ򺮺ߤ뤳ȤϤ
        ޤ ? 

        Sun ǤϺߤ侩ޤ󡣡֥ץ饰פưŪɤ߹ߥ饤
        ǤäƤ⡢ͳ顢ƱץΥɤκߤ
        ݡȤƤޤ

          o 饹֥Ȥ֤ۤʤ롣

          o ؿθƤӽФۤʤ롣

          o ̾沽׽ۤʤ롣

          o 㳰ˡ̷⤹롣

          o 2 Ĥϥȥ꡼४֥ȤƱե뵭һҤ
            ³꤬ȯ롣

        ץ 2 Ĥʬ (ߴ⡼ɤɸ⡼) ̿ʤ
        ȤǤ⡢㳰()ȡץब
        ˥å夹ǽޤ

        ˤäƤϡߴ⡼ɤɸ⡼ɤΥ֥ȥե
        ޤȤƥ󥯤Ǥޤ ˤĤƤϡѥ°
        ƤC++ ܹԥɡ٤ǾܤƤޤ  1 
        ֿХʥκߡפ򻲾ȤƤΥɤϡ 
        http://docs.sun.com 饪饤Ǥޤ

      2.C++ ޤ C ץ F77F90ޤ F95 ץ
        ߹碌ˤϡɤФ褤Ǥ礦 ? 

        Workshop 6 update 1 (ѥΥС 5.2) ʹߡ
        -xlang={f90|f95|f77} ץѤǤ褦ˤʤޤ
        Υץϡ󥯹Ԥɬפʥ饤֥ȤΥ饤֥
        ɬפʽиΤ˳Ф褦ɥ饤Ф˻ؼޤ

         -xlang ץϡC ѥˤϻѤǤޤ C 
        롼 Fortran 롼Ȥ߹碌ˤϡcc ǥѥ
        Fortran 󥫡ǥ󥯤ɬפޤ


    D. ǥ󥰤ӿ
      1.ѥ餫ɸ㳰饹ˤĤƤΤޤ𤵤
        ΤϤʤǤ ? 

      2.C++ 5.3 ۴ؿΥ˴ؤƥ顼ФΤ
        ʤǤ ? 

      3.ץ󥯤ȥƥץ졼ȥ󥹥󥹤Τ
        ʤǤ ? 󥹥󥹤ϥƥץ졼ȥåˤ褦
        Ǥ 

      4.+w2 ѤƤȤޤ +w2 +d ѤƤʤȤˡ
        ؿŸʤȤٹåɽΤϤʤǤ
         ? 

      5.-ptr ץȤäơʣΥƥץ졼ȥݥȥѤ
        ꡢʣΥץȴ֤ǥݥȥͭǤޤ ?
        ǤʤϡɤΤ褦ˤФ褤Ǥ礦 ? 

      6.Τ褦ʥåɽ뤳Ȥޤ SunWS_cache:
        : ֥ǡ١åƤޤԵǤ...פ
        Ϥɤ̣Ǥ? ϲǤ? I֤ɬפǤ?
        ɤФΥåФʤ褦ˤǤޤ ? 

      7.printf("%s",NULL) ʤ㳰θˤʤΤǤ ? 

      8.sqrt() θƤӽФˡˤäơʣǿʿε椬
        ʤޤ ϤʤǤ ? 

      9.饹ƥץ졼Υեɴؿϥ󥹥󥹲줺
        ˥顼ˤʤޤ C++ 5.0 ǤϤΤ褦ʤȤϤ
        ǤΥСǥ顼ˤʤΤϤʤǤ ? 

     10.Ҥˤʤä饹ޤ륯饹ΥС˥
        ʤȤΤϤʤǤ ? 

     11.¹Իˡpure virtual function call (ؿƤӽФ)ץ
        ɽ븶ϲǤ ? 

     12.饹β۴ؿϡ̷ΰۤʤ쥯饹β۴ؿ
        ȤΤϤʤǤ ? ¾Υѥξ硢Υ
        ˤϲ꤬ޤ 

    ------------------------------------------------------------------

      1.ѥ餫ɸ㳰饹ˤĤƤΤޤ𤵤
        ΤϤʤǤ ? 

        Solaris Ǥϡɸإå <math.h> ˡɸ Unix ɬפ
        ¤ΡexceptionѤޤ using ޤ
        using Ѥ C++ ɸ㳰饹襹פ
        ȡͤȯޤ 

        // Example 1

        #include <math.h>
        #include <exception>
        using namespace std; // using 
        exception E;  // 顼㳰ޤ

        // Example 2:

        #include <math.h>
        #include <exception>
        using std::exception; // using 
        exception E;  // 顼㳰Ф¿
        
        using   using Ӥȡ̯̾˰ۤʤ
        Τᡢ顼åϴ˰פޤ

        :
            1.<math.h>  <cmath> ѤƤ Solaris
               <cmath> ˤϡC  C++ ʤǻꤵƤ
              ޤޤޤ <math.h>  UNIX ͭεǽɬפǤ
              硢βϻѤǤޤ 

            2.<math.h> Ѥϡusing std::exception;ȵҤ
              ʤǤ Ū std::exception 򵭽Ҥ뤫
              typedef Ѥɸ㳰饹˥Ƥ
              򼨤ޤ 

            #include <math.h>
            #include <exception>
            std::exception E; // OK
            typedef std::exception stdException; // OK
            stdException F; // OK

            3.using namespace std; 򵭽ҤʤǤ 
            C++ ͡ॹڡ std ˤ¿̾ޤޤ뤿
            ºݤΥɤǤλѤȡץꥱ󥳡
            ޤϥɥѡƥΥ饤֥Ⱦͤǽޤ
            (C++ ץߥ󥰤˴ؤҤ䵭Ǥϡ using 
            ƾʥץץ򤵤ñ㲽Ƥ뤳
            Ȥޤ) ġ using Ūʽ̾
            ޤ 

      2.C++ 5.3 ۴ؿΥ˴ؤƥ顼ФΤ
        ʤǤ ? 

        5.3 C++ ѥ餬˶ C++ §Ǥϡ饹
        ۴ؿϡ񤭤ؿƤ㳰ΤߤƤǤޤ
        񤭴ؿ¤򶯲뤳ȤϤǤޤ¤ˤ뤳Ȥ
        Ǥޤ ǹͤƤߤƤ 

        class Base {
        public:
            // int 㳰ϥǤ뤬ʳϥǤʤ
            virtual void f() throw(int);
        };
        class Der1 : public Base {
        public:
            virtual void f() throw(int); // ok, Ʊ
        };
        class Der2 : public Base {
        public:
            virtual void f() throw(); // ok, 긷
        };
        class Der3 : public Base {
        public:
            virtual void f() throw(int, long); // 顼, long ǧʤ
        };
        class Der4 : public Base {
        public:
            virtual void f() throw(char*); // 顼, char* ǧʤ
        };
        class Der5 : public Base {
        public:
            virtual void f(); // 顼, 㳰ǧƤ
        };

        ΥɤϡC++ §λܹͳ򼨤Ƥޤ 

        #include "base.h" // Base 饹
        void foo(Base* bp) throw()
        {
            try {
               bp->f();
            }
            catch(int) {
            }
        }

        Base::f()  int 㳰Τߤ򥹥褦Ƥ뤿
        ؿ foo ϡint 㳰ªǽǤꡢ㳰Υפ
        ƤʤȤޤ ï˥饹 Der5 
        ͤƤߤޤ礦Ǥǡ񤭴ؿǤդ㳰
        Der5 ݥ󥿤 foo ϤȤǤޤ ؿ foo 
        Υѥ˲Ļ륳ɤ꤬ʤǤ⡢ؿ foo ̵
        ˤʤޤ

      3.ץ󥯤ȥƥץ졼ȥ󥹥󥹤Τ
        ʤǤ ? 󥹥󥹤ϥƥץ졼ȥåˤ褦
        Ǥ 

        ƥץ졼ȥåϡѥ餬륪֥ȥե
        ֤ΰ¸طꥹȤͭƥץ졼ȥ󥹥󥹤
        å˴ޤޤƤޤ ߤΥѥϡ
        -instances=extern ꤵƤˤΤߥƥץ졼ȥ
        Ѥ褦ˤʤäƤ뤳ȤդƤ֥
        ȥեưޤ̾ѹ뤫֥ȥե
        饤֥˷礷硢åؤ³ޤ 
        2 Ĥؼʤ򼡤˼ޤ

          1.֥ȥեľŪ˺ǽǥ쥯ȥޤ
            ƥץ졼ȥåƱǥ쥯ȥ֤ޤ

            ϻѤʤǤ 

            example% CC -c -instances=extern f1.cc
            example% mv f1.o /new/location/for/files

            ˼ѤƤ 

            example% CC -c -instances=extern f1.cc -o /new/location/for/files/f1.o

            makefile ޥǥץ򥫥ץ벽Ǥޤ

          2.CC -xar ѤȡŪʥ֥ե (.a) 
            Ǥޤ 줾Υ֤ˤϡΥ
            ȤѤ뤹٤ƤΥƥץ졼ȥ󥹥󥹤ޤޤ
            ޤ Υ֤ǽץ˥󥯤ޤ 
            Υƥץ졼ȥ󥹥󥹤ϰۤʤ륢֤ǽʣ
            Ʊ쥢֤ǽʣʤ褦˥󥫡ޤ

            example% CC -c -instances=extern f1.cc f2.cc f3.cc
            example% CC -xar f1.o f2.o f3.o -o temp1.a
            example% CC -c -instances=extern f4.cc f5.cc f6.cc
            example% CC -xar f4.o f5.0 f6.0 -o temp2.a
            example% CC -c -instances=extern main.cc
            example% CC main.o temp1.a temp2.a -o main

      4.+w2 ѤƤȤޤ +w2 +d ѤƤʤȤˡ
        ؿŸʤȤٹåɽΤϤʤǤ
         ? 

        C++ ѥˤϡ 2 Υ饤󲽤ޤ ѡ
        ˤäƹԤ C++  inline ؿΥ饤󲽤ȡ
        ɥͥ졼ˤäƹԤŬΥ饤󲽤Ǥ C 
         Fortran ѥˤϡŬΥ饤󲽤
        ޤ (1 ĤΥץåȥեǤϡ٤ƤΥѥФ
        Ʊɥͥ졼Ѥޤ)

        C++ ѥΥѡϡۤˤ뤤Ū inline Ȥ
        줿٤ƤδؿΥ饤󲽤Ÿ褦Ȼߤޤ
         ؿ礭ȡѡϡ+w2 ץѤƤ
         ˤٹȯޤ +d ץϡѡؿ
         饤󲽤ʤ褦ˤޤ Τᡢ+d Ѥȷ
         åɽޤ (ޤ-g ץꤷ
         ⡢C++ 饤ؿϥ饤󲽤ޤ) -xO 
         ϡΥפΥ饤󲽤ˤϲƶͿޤ

        ŬΥ饤󲽤ϡץ˺ޤ -xO4
        ޤϤ⤤Ŭ٥򤹤ȡɥͥ졼
        ϡؿǤɤΤ褦Ƥ褦Ȥ⡢
        Ƥδؿ򸡺ơ֤СؿƤӽФ򥤥
        饤󥳡ɤ֤ޤ ŬΥ饤 (뤤ϡ
        ؿΥ饤󲽤μ) ˴ؤåϲɽޤ
         +d ץϡŬΥ饤󲽤ˤϲƶͿ
        

      5.-ptr ץȤäơʣΥƥץ졼ȥݥȥѤ
        ꡢʣΥץȴ֤ǥݥȥͭǤޤ ?
        ǤʤϡɤΤ褦ˤФ褤Ǥ礦 ? 

        -ptr ץϡС 5.0 - 5.6 ǤϥݡȤƤ
        󡣥С 4.2 󶡤Ƥޤɬ桼
        δԤɤ˵ǽ¿ȯƤޤ

        ɤΥɥХϡʣΥץȴ֤ǥݥȥͭ
        ȤǤ ݥȥͭȡޤʤۤɿ
        ꤬ȯǽޤ 1 ĤΥץȤ 1 ĤΥ
        쥯ȥǥѥ뤷Ƥ ̤ΥץȤΥ
        ʥˤ̤Υǥ쥯ȥѤƤ

        С 5.0 ʹߡѥϡ륪֥ȥե
        Ʊǥ쥯ȥ˥ƥץ졼ȥݥȥǼޤ 1 
        ĤΥץȤʣΥݥȥѤϡط
        ݥȥǼǥ쥯ȥ˥֥ȥե
         󥯻饪֥ȥե˴ط
        ȥФơưŪ˥ƥץ졼ȥ󥹥󥹤θԤ
        ޤ ѥ饪ץɬפޤ

      6.Τ褦ʥåɽ뤳Ȥޤ SunWS_cache:
        ־: ǡ١åƤޤԵǤ... 
        Ϥɤ̣Ǥ ? ϤʤǤ? ֤ɬפǤ?
        ɤФΥåФʤ褦ˤǤޤ ? 

        ƥץ졼ȤѤץ򥳥ѥ뤹Ȥˡ
        SunWS_cache/CC_state Υѥ־ιɬפʾ
        ѥϡɬ SunWS_cache ϥǥ쥯ȥåޤ
        ƥץ졼ȤѤʣΥץƱǥ쥯ȥǥ
        뤷褦Ȥˤϡ٤ 1 ĤΥץå
        ޤ

        С 4.25.0 5.1  C++ ѥϡå
        ԤΥץȤɬ SunWS_cache: : ǡ
        ١åƤޤԵǤ... Ȥå
        Ϥޤ Υåñ˾Τ뤿ΤΤǤ
        顢̵뤷Ƥ Υåϡ̤Υѥ
        ץǡ١åȤȤ̣Ƥޤ
        ̤Υ֤λȡߤΥ֤³Ԥޤ dmake
        ѤƤ뤿ˡΥåФȹͤޤ 
        ΥåФʤ褦ˤ뤳ȤϤǤޤ ǿ C++ 
        5.2 ѥåC++ 5.3 ѥ顢5.4 ѥ顢 5.5 
        ѥǤϡ̤ΥåѤƤꡢΥå
        Фޤ

    7.printf("%s",NULL) ʤ㳰θˤʤΤǤ ? 

        ץꥱˤϡNULL ʸݥ󥿤϶ʸؤΥݥ
        󥿤Ʊ򤷤ʤФʤʤȸäǧƤΤ
        ޤ ΥץꥱǤϡNULL ʸݥ󥿤
        ȥȰȿȯޤ

        Ĥͳˤꡢ *printf() δؿեߥˤ NULL ݥ
        󥿤Υåǽޤ ˸¤ޤ󤬡
        褦ʤȤ󤲤ޤ

            1.åǽԤȡä¿Ϳ롣 ץ
              ޤˡprintf() ؤ NULL ݥ󥿰Ϥޤ
              ȻפޤƤޤޤ

            2.ץޤܿΤʤɤ񤯤ȤĹ롣 
              ANSI CXPG3XPG4SVID2 SVID3 Ǥϡ
              printf("%s", pointer) ˤ NULL ǽʸؤ 
              pointer ݥȤʤФʤʤȵꤵƤޤ

            3.ǥХå񤷤ʤ롣 ץޤ NULL ݥ󥿤
              printf() ϤƤץबΤǤС
              ǥХåѤСʥݥ󥿤ꤷ printf()
              ƤӽФñ˸ĤФȤǤޤ  
              printf()  "(NULL ݥ)" ȽϤ뤳Ȥˤꡢ
              ΥХɽˤ硢θǿʹԤۤΥץ
              ϡºݤΥǡߤȤˡ
              "(NULL ݥ)" ᤷ褦ȤǤ礦 λ
              Ǥϡºݤ꤬ɤ˱Ƥ뤫ȽǤ뤳ȤԲǽ
              ⤷ޤ 

        NULL ݥ󥿤 *printf Ϥץꥱ󤬤ϡ
         0  0 ꤹ뤿Υᥫ˥󶡤
        ֥ͭ /usr/lib/0@0.so.1 Ѥ뤳ȤǤޤ
        Υ饤֥ϡNULL ݥ󥿤ηˤ㤤˴Ϣ뤹٤
        Υ顼ޥΤǡΥ饤֥ϡɤ
        ǤΰŪʲȤƤλѤ˸ꤷƤ

      8.sqrt() θƤӽФˡˤäơʣǿʿε椬
        ʤޤϤʤǤ ? ϤʤǤ ?

        δؿμϡC99 csqrt Annex G ͡פǵꤵƤޤ
        ȤСΥνϤ򸫤Ƥ

        complex sqrt (3.87267e-17, 0.632456) 
        float sqrt (3.87267e-17, -0.632456)
        
        1.ߴ⡼ɤ libcomplex Ѥ: 
        
        #include <iostream.h>
        #include <math.h>
        #include <complex.h>
         
        int main ()
        {
              complex ctemp(-0.4,0.0);
              complex c1(1.0,0.0);
              double  dtemp(-0.4);
              cout<< "complex sqrt "<< sqrt(ctemp)<<endl;
              cout<< "float sqrt   "<< sqrt(c1*dtemp)<<endl;
        }

        2.ɸ⡼ɤ libCstd Ѥ: 

        #include <iostream>
        #include <math.h>
        #include <complex>
         
        using namespace std;
         
        int main ()
        {
             complex<double> ctemp(-0.4,0.0);
             complex<double> c1(1.0,0.0);
             double  dtemp(-0.4);
             cout<< "complex sqrt "<< sqrt(ctemp)<<endl;
             cout<< "float sqrt   "<< sqrt(c1*dtemp)<<endl;
        }

        3.complex  sqrt ؿϡatan2 ѤƼޤ
         atan2 Ѥ뤳ȤˤäƵ򼨤ΤǤ
        ΥץνϤϰʲΤȤǤ 

            c=-0.000000  b=-0.400000  atan2(c, b)=-3.141593
            a=0.000000  b=-0.400000  atan2(a, b)=3.141593

        1 ĤǤϡatan2 νϤοˤʤꡢ2 ĤǤ
        Ǥ ϡǽΰȤ -0.0 ޤ 0.0 Τɤ餬
        뤫ˤޤ 
          
        #include <stdio.h>
        #include <math.h>
         
        int main()
        {
            double a = 0.0;
            double b = -0.4;
            double c = a*b;
            double d = atan2(c, b);
            double e = atan2(a, b);
            printf("c=%f  b=%f  atan2(c, b)=%f\n", c, b, d);
            printf("a=%f  b=%f  atan2(a, b)=%f\n", a, b, e);
        }

      9.饹ƥץ졼Υեɴؿϥ󥹥󥹲줺
        ˥顼ˤʤޤ C++ 5.0 ǤϤΤ褦ʤȤϤޤ
        ǤΥСǥ顼ˤʤΤϤʤǤ ?

        ΥƥȥϡC++ 5.0 ѥǤϡ顼ʤ˥
        뤪ӥ󥯤ԤޤʹߤΥСΥѥ
        ϡ󥯥२顼ȯޤ 

        example% cat t.c

        #include <ostream>

        using std::ostream;

        template <class T> 
        class TList {
        public:
          friend ostream& operator (ostream&, const TList&);
        };

        template <class T>
        ostream& operator (ostream& os, const TList<T>& l)
        {
          return os; 
        }

        class OrderedEntityList {
        public:
          TList<int> *Items; 
          ostream& Print(ostream &) const;
        };

        ostream& 
        OrderedEntityList::Print(ostream& os) const
        {
          os  *Items;
          return os;
        }

        main()
        {
        }

        example% CC t.c

        Undefined                       first referenced
        symbol                              in file
        std::basic_ostream<char,std::char_traits<char> 
        >&operator (std::basic_ostream<char,std::char_traits<char &,const 
        TList<int>&) 4421826.o

        ld: fatal: Symbol referencing errors. No output written to test
        
        ʤˤȡΥƥȥ̵Ǥ ϰʲ
        ˤޤ
 
        friend ostream& operator (ostream&, const TList&);
        
        ϡΥƥץ졼ȥ󥹥󥹤⻲ȤƤޤ
        
        󽤾̾λȤϡե 1 սǧǽǤȤ
        ⡢ƥץ졼Ȱפޤ եƥץ졼
        ȤȰפˤϡեƥץ졼ȴؿȤ
        뤫ޤ̾򽤾ɬפޤ 
        
        ɤˡǤ⡢ƥץ졼Ѥϡե 1 
        ǧǽǤɬפޤ 
        
        Ĥޤꡢեϥƥץ졼Ȥ򻲾Ȥޤ󤬡ؿƤӽ
        ˤäȤפؿޤ (ۤΤǤ
        Сƥץ졼ȴؿƥץ졼ȤǤʤؿΤ
        ȸޤ) 
        
        ΥɤͭǤ 

        template <class T> class TList; 
        // ǡoperator<< ƥץ졼ȤǤ

        template <class T> 
        ostream& 
        operator (ostream& os, const TList<T>& l) 
        { 
          return os; 
        } 

        template <class T> 
        class TList {
        public :
          // ؿ̾Υ׽
          friend ostream& ::operator (ostream&, const TList&);
        };

     10.Ҥˤʤä饹ޤ륯饹ΥС˥
        ʤȤΤϤʤǤ ? 
         
        class Outer {
            typedef int my_int;
            static int k;
            class Inner {
                my_int j;     // 顼my_int ˤϥǤʤ
                int foo() {
                        return k; // 顼k ˤϥǤʤ
                        }
                };
        };
         
        ARM  C++ ɸˤȡҤˤʤä饹ϡޤ
        饹ΥС̤˥뤳ȤϤޤ my_int 
         k  Outer ʤΤǡOuter Υեɤ
        С˥Ǥޤ Ҥˤʤä饹եɤˤ
        ˤϡ饹äƤեɤˤɬפ
        ޤʲ򼨤ޤ 
        
        class Outer {
            typedef int my_int;
            static int k;
                //  2 Ԥ򥯥饹ɲ
            class Inner;  
            friend class Inner;

            class Inner {
                my_int j;         // OK
                int foo() {
                        return k; // OK
                        }
                };
        };

     11.¹Իˡpure virtual function call (貾۴ؿƤӽФ)
        åɽ븶ϲǤ ?

        ץˡ륨顼ȯɬpure virtual 
        function call (ؿƤӽФ)ץåɽޤ 
        Υ顼ϡ 2 ĤΤɤ餫ξ˵ޤ 
        
          1.Υ顼ϡݥ饹Υ󥹥ȥ饯ޤϥǥȥ饯
            顢ؿˡthisץѥ᡼ϤȤˤäȯ
            ޤ ۤ˲ˡthisפϡ󥹥ȥ饯
            ϥǥȥ饯ȤΥ饹ηǽŪ˹ۤ
            饹ηϻޤ ǽ貾۴ؿθƤӽФ
            뤳ȤǤޤ ǹͤƤߤƤ 
          
            class Abstract;

            void f(Abstract*);

            class Abstract {
            public:
                    virtual void m() = 0; // 貾۴ؿ
                    Abstract() { f(this); }   // 󥹥ȥ饯 "this" Ϥ
            };

            void f(Abstract* p)
            {
                    p->m();
            }

            Abstractץ󥹥ȥ饯 f ƤӽФȡ
            thisפϡAbstract*׷Ȥʤꡢؿ f Ͻ貾۴ؿ m 
            ƤӽФȤޤ 

          2.ŪʽһԤ鷺貾۴ؿƤӽФ
            Ȥˤ⡢Υ顼뤳Ȥޤ 
            ˽貾۴ؿꤹ뤳ȤϤǤޤƤӽФˤϽ
            ƤӽФȤǤޤ 

            class Abstract {
            public:
                    virtual void m() = 0; // Τϸ󶡤
                    void g();
            };

            void Abstract::m() { ... } // m 

            void Abstract::g()
            {
                    m(); // 顼貾ۤ m ƤӽФȤƤ
                    Abstract::m(); // OKƤӽФϴ˽Ƥ
            }

     12.饹β۴ؿϡ̷ΰۤʤ쥯饹β۴ؿ
        ȤΤϤʤǤ ? ¾Υѥξ硢Υ
        ˤϲ꤬ޤ 

        C++ ε§Ǥϡ¿ϥǤΤǧ졢פ
        ĶΤǧޤ 쥯饹ϡ饹Υ
        פ괬ˤȹͤޤ Τᡢ
        饹줿̾ϡ쥯饹Τؿ򱣤¿
        Ǥޤ δŪ C++ §ϡARM 켰
         

        ۤΥѥ餬۾ɽʤȤƤ⡢ˤ»
        ޤʤʤ顢ɤϡԤȤˤưʤ
        Ǥ Sun ΥѥϡΥɤդȤ˷
        ɽޤ (ʥɤǤ餯Ԥɤˤư
        ޤ) 

        ¿줿åȤ˴쥯饹ؿޤ᤿ϡ쥯
        ؿ򸽺ߤΥפ뤿˼äɬפޤ
        ǥեȤɸ⡼ɤǥѥԤäƤϡλ
        ѤɲäǤޤ 

        class Base {
        public:
                virtual int    foo(int);
                virtual double foo(double);
        };

        class Derived : public Base {
        public:
                using Base::foo; // 쥯饹ؿ¿åȤɲ
                virtual double foo(double); // 쥯饹С֤


    E. 饤֥θߴ

      1. C++ ɸ饤֥ (stdlib) ˡ򶵤Ƥ
         뤤ϡߤ libCstd ݡȤƤʤǽˤϡ
        ɤΤ褦ʤΤޤ ? 

      2.C++ ɸΥƥץ졼ȥ饤֥ (STL) ɬפǤ ɤ
        ǤΤǤ礦 ? ߴ⡼ (-compat) ѤΤΤϤΤǤ
        礦 ? 

      3.libCstd Ǽ줿ɸ饤֥굡ǽˤϤɤΤ褦ʤΤ
         ? 

      4.ɸ饤֥εǽ뤳ȤǡɤΤ褦ʱƶΤ
        礦 ? 

      5.ɸॹȥ꡼ǵǽ tools7 饤֥СϤޤ
         ? 뤤 tools8 ϤޤʤǤ褦ˤʤΤǤ礦
         ? 

    ------------------------------------------------------------------

      1. C++ ɸ饤֥ (stdlib) ˡ򶵤Ƥ
         뤤ϡߤ libCstd ݡȤƤʤǽˤϡ
        ɤΤ褦ʤΤޤ ? 

        Υ꡼ˤϡSTLport  Standard Library ΥС
        4.5.3 ץɸ饤֥ȤƴޤޤƤޤ
        STLport  C++ ʤ˸̩˽򤷤Ƥʤ顢Ūʳĥǽ
        ݻƤޤ ǥեȤǻѤɸ饤֥
        ȤΥХʥߴϤޤ

        ߤ libCstd ϡС 5.0  C++ ѥѤ˳ȯ
        ޤ ΥСϡ饹ΥСȤƥƥץ졼
        Ȥ򥵥ݡȤƤޤ ɸ饤֥ΰˤϡС
        ƥץ졼ȤɬפǤꡢΤȤϰǽ뤳Ȥ
        ̣ޤ äˡۤηѴǽˤ륳󥹥ȥ饯
        ƥץ졼Ȥĥƥʥ饹ˤƵޤ ξ
        ϡȤƥŪʷѴ򵭽Ҥɬפ
        ޤ

        С 5.1 ʹߡC++ ѥϥ饹ΥСȤ
        ƥץ졼Ȥ򥵥ݡȤƤơʤ˽򤷤饤֥
        Ǥޤ ȥХʥ٥θߴ»ʤȤʤ饤
        ֥򹹿뤳ȤϤǤʤᡢǤϡƱ¤ 
        libCstd ³в٤Ƥޤ

        gnu  SGI  Web ȤǤϡѥ֥åǤɸ饤֥꤬
        ۤƤޤޤRogueWaveDinkumware ʤɤΥ٥
        饤֥뤳ȤǤޤ STL ˤĤƤϡμ
        򻲾ȤƤ

      2.C++ ɸΥƥץ졼ȥ饤֥ (STL) ɬפǤ ɤ
        ǤΤǤ礦 ߴ⡼ (-compat) ѤΤΤϤΤ
        礦 ? 

        C++ ѥϸߡSTLport  Standard Library С
         4.5.3 򥵥ݡȤƤޤǥեȤΥ饤֥ϸ
        ߤ libCstd ǤSTLport ʤ˻ѤǤ褦ˤ
        ޤ Υ꡼ˤϡŪ libstlport.a ư
        Ū饤֥ libstlport.so ξޤǤޤ 

        Υѥ饪ץꤹȡlibCstd ̵ˤ 
        STLport ѤǤޤ

        -library=stlport4

        ǥեȤ C++ ɸ饤֥ libCstd  STLport ξ 
        STL ޤǤޤ ̤ΥСɸ饤֥ѤǤ
        ޤȼɹʷ̤ݾڤǤޤ

        ̤ STL ץ饰󤹤ˤϡ -library=no%Cstd ץ
        Ѥơѥ餬ºݤ˻Ѥإåե뤪ӥ饤
        ֥򸫤Ĥ褦ˤޤ ѤΥ饤֥Ѥ
         iostreams ʤɸ iostreams ˡֽפ
         iostreams ѤǤϡޥɹԤ -library=iostream
        ɲäޤ ܺ٤ʼˤĤƤϡѥ°C++
        桼ɡ٤ΡC++ ɸ饤֥֤פ򻲾Ȥ
         Υɤϡhttp://docs.sun.com 饪饤
        Ǥޤ

        Υ꡼Ǥϡ-compat ⡼ɤбɸ饤֥굡ǽ
        󶡤Ƥޤ ɥѡƥΥ饤֥ (LTLport ʤ) 
         -compat ⡼Ѥ˹Ǥ⤢ޤΥ꡼
        ϤΤ褦ʹ򥵥ݡȤޤ
        
      3.libCstd Ǽ줿ɸ饤֥굡ǽˤϤɤΤ褦ʤΤ
         ? 

        ɸ饤֥ϡ (C++ 5.0 Ǥ) ѥ˥С
        ץ졼Ȥʬü첽ɬפȤ뵡ǽ򥵥ݡȤ˹
        ۤ줿ΤǤ εǽ C++ 5.1 ʹߡѲǽǤ
        ɸ饤֥ͭˤ뤳ȤϤǤޤ󡣤ϲߴ
        ݻ뤿ǤϡƵǽ̵ˤ졢εǽ
        줿ǽꥹȤǤ

        o ̵ˤ줿ǽ: Сƥץ졼ȴؿ

          + <complex>  complex 饹: 

            template <class X> complex<T>& operator= (const 
            complex<X>& rhs) 
            template <class X> complex<T>& operator+= (const 
            complex<X>& rhs) 
            template <class X> complex<T>& operator-= (const 
            complex<X>& rhs) 
            template <class X> complex<T>& operator*= (const 
            complex<X>& rhs) 
            template <class X> complex<T>& operator/= (const 
            complex<X>&)

          + <utility>  pair 饹:

            template<class U, class V> pair(const pair<U, V> &p);

          + <locale>  locale 饹:

            template <class Facet> locale combine(const locale& 
            other);

          + <memory>  auto_Ptr 饹:

            auto_ptr(auto_ptr<Y>&); 
            auto_ptr<Y>& operator =(auto_ptr<Y>&); 
            template <class Y> operator auto_ptr_ref<Y>(); 
            template <class Y> operator auto_ptr<Y>();

          + <list>  list 饹: 

            Сƥץ졼ȤΥ

          + ۤȤɤΥƥץ졼ȥ饹: 

            ƥץ졼ȥ󥹥ȥ饯

        o ̵ˤ줿ǽ: Сƥץ졼ȥ饹

          <memory>  auto_ptr 饹:
          template <class Y> class auto_ptr_ref{}; 
          auto_ptr(auto_ptr(ref<X>&);

        o ̵ˤ줿ǽ: ʬŪü첽Ƥؿƥץ졼Ȥ
          ¿

          In <deque>, <map>, <set>, <string>, <vector> and <iterator> 
          the following template functions (non-member) are not 
          supported:

          + mapmultimap setmultisetbasic_stringvector
            reverse_iterator istream_iterator 饹ξ:

            bool operator!= ()

          + mapmultimap setmultisetbasic_stringvector
             reverse_iterator 饹ξ:

            bool operator> () 
            bool operator>= () 
            bool operator<= ()

          + mapmultimap setmultisetbasic_string vector
          饹ξ:

            void swap()
         
        o ̵ˤ줿ǽ: ǥեȤΥѥ᡼Ȥäƥץ졼
          饹ʬü첽

        <algorithm> ǤϡΥƥץ졼ȴؿ (С) ϥݡ
        ޤ

        count(), count_if()

        <iterator> ǤϡΥƥץ졼ȤϥݡȤޤ

        template <class Iterator> struct iterator_traits {} 
        template <class T> struct iterator_traits<T*> {} 
        template <class T> struct iterator_traits<const T*> {}
        template typename iterator_traits::difference_type 
        distance(InputIterator first, InputIterator last);


      4.ɸ饤֥εǽ뤳ȤǡɤΤ褦ʱƶΤ
        礦 ? 

        C++ ʤǤʥɤѥ뤵ʤȤޤ

        äȤ褯Τϡڥ 1 Ǥ const ǤΤˡ
        褦ˤƤʤޥåפƤǤ 
        С󥹥ȥ饯ƥץ졼Ȥϡɬפ˱ۤ pair<T, U> 
         pair<const T, U> Ѵޤ 󥹥ȥ饯
        ˡѴ줺ˡѥ륨顼ˤʤޤ

        ޥåΥڥ 1 Ǥѹ뤳ȤϤǤʤᡢä
        ñʲϡڥȤŪ const 
        뤳ȤǤ ȤСpair<int, T> ǤϤʤ 
        pair<const int, T> Ѥޤޤmap<int, T> ǤϤʤ 
        map<const int, T> Ѥޤ

      5.ɸॹȥ꡼ǵǽ tools7 饤֥СϤޤ
         ? 뤤 tools8 ϤޤʤǤ褦ˤʤΤǤ礦
         ? 

        ϤޤC++ 5.35.45.5  5.6 ΤߤǤ
        -library=rwtools7_std ޥɤѤƤΥ饤֥ȥ
        Ƥ

        RogueWave  Tools.h++ εǽѹƤꡢߤǤ 
        SourcePro ʤΰȤƤΤ󶡤Ƥޤ Τ褦ͳ
        顢Tools.h++ version 8 ¸ߤޤ


    F. ѥΥѥեޥ󥹤θ

      1.С 4.2 ٤ơС 5.0  5.1 Υѥ
        Υѥ֤ĹʤäƤޤ 衢
        褵ΤǤ礦 ? 

      2.С 4.2 Υѥ٤ƥХʥΥʤ
        ʤޤ βϤΤǤ礦 ? 

      3.1 ĤΥѥץʣΥץåʬǤǤ礦
         ? Ūˡޥץå (MP) ƥѥ
        Υѥեޥ󥹤ϾɤΤǤ礦 ? 

    ------------------------------------------------------------------

      1.С 4.2 ٤ơС 5.0  5.1 Υѥ
        Υѥ֤ĹʤäƤޤ 衢
        褵ΤǤ礦 ? 

        5.1 Υѥå 01С 5.25.35.45.55.6 ǡ
        ѥ֤ޤѥΥѥեޥ󥹤­
        Ǥʤ硢ο侩αդƤ

            a.üʾ硢饤󲽤ʻ֤븶ˤʤ
             -xO4 ޤ -xO5 Τ줫ΥץѤȡ
            ɥͥ졼ĤδؿưŪ˥饤󲽤
            ޤ -xO3 Τ褦㤤Ŭ٥Ѥɬפ뤫
            ⤷ޤ󡣥ץƥޥؿưŪ˥饤
            ʤ褦ˤˤϡ-xinline ץѤǤޤ

            b.礭ʴؿŪʥ饤󲽤̵ˤޤ Ū
            ʥ饤󲽤ξܺ٤ˤĤƤϡʲ򻲾ȤƤ

      2.С 4.2 Υѥ٤ƥХʥΥʤ
        ʤޤ βϤΤǤ礦 ? 

        -g ץǥѥԤȡС 5.0 饳ѥ
        餬ƥץ졼ȤΥǥХåѤ̤ξ񤭽ФᡢХ
        Υ礭ʤޤ С 5.1 Ǥϡ¿μ
        ץˤĤơǥХåΥ˽̾
        ޤ 5.25.35.45.55.6 ѥǤϡ˲ɤ
        졢¿ξˡХʥꥵν̾Ψ 25%  50% 
        ʤäƤޤ ɤϡɤ֤̾ƥץ졼ȡ
        ¿ηѾ٥ĥ饹ؤѤƤä˸
        Ǥ

     3. 1 ĤΥѥץʣΥץåʬǤǤ礦
         ? Ūˡ˥ޥץå (MP) ƥ
        Υѥեޥ󥹤ϾɤΤǤ礦 ? 

        ѥ餽ΤΤϥޥåɲƤޤ 
        ѥ 1 ΥѥǾ¿¾ΥץƱ
        ư뤿ᡢMP ƥѥեޥ󥹤θԤ
        ޤ

        dmake (ѥ°Ƥġ 1 ) Ѥȡ
        ʣΥѥƱ˼¹ԤǤޤ 


    G. ¹ԻΥѥեޥ󥹤θ

      1.C++ ϡ"inline" ɤդؿ˥饤󲽤
        ΤǤ礦 ? 뤤ϡΤ褦˵ҤȤƤ⡢饤
        󲽤ʤؿΤϡɤƤǤ礦 ? 

      2.stdlib ȥ꡼ϡgcc ޤ KAI ȥ꡼®Ǥ 
        ѥեޥ󥹤㲼礭ޤ ϤΤǤ礦?

    ------------------------------------------------------------------

      1.C++ ϡ"inline" ɤդؿ˥饤󲽤
        ΤǤ礦 ? 뤤ϡΤ褦˵ҤȤƤ⡢饤
        󲽤ʤؿΤϤɤƤǤ礦 ? 

        Ūˡѥϡinline ȤߤʤΤ褦
        줿ؿ򥤥饤󲽤褦ȤޤС 5.1 
         5.6 ޤǤΥѥǤϡ饤󲽥르ꥺबɤ
        졢¿ιʸ򤹤褦ˤʤäƤޤ  
        Ǥ⡢ʸǤʤ¸ߤޤ
        ˼ޤ

        С 5.2 - 5.6  C++ ѥǤϡۤȤɼ¹Ԥ
        ȤΤʤؿƤӽФŸޤ󡣤ѹϡ
        ®١ϥɥӼ¹Ի®٤ζѹդȤ
        Ωޤ

        ȤСŪѿǻѤ뼰 1 ٤¹Ԥ
        ᡢδؿƤӽФŸޤ 饤ؿ 
        func ϡŪѿνǸƤӽФȡŸʤ
        Ȥ뤳ȤդƤۤξǥ饤󲽤줿
        ޤޤǤ Ʊͤˡ㳰ϥɥδؿƤӽФϡ
        ɤˤä˼¹ԤʤΤǡŸʤǽޤ

        ƵؿϡǽθƤӽФ٥ФƤΤߥ饤󲽤
         ѥϡƵؿθƤӽФ򤢤ޤ˥饤
        Ǥޤ ߤμϡ饤󲽤ƤǤդδؿ
        νƤӽФλߤޤ

        ȤơʴؿФƤӽФǤ⥤饤󲽤
        Ȥޤ ͳϡŸιץ礭
        ȤȤǤ ȤСfunc1  func2 ƤӽФfunc2 
        func3 ƤӽФȤ褦ʾ礬ޤ δؿ
        ơƵŪʸƤӽФϤʤǤ⡢ѥ餬餹
        ٤ƤŸˤϡŸΥιפ礭ǽ
        ޤ

        ¿ɸƥץ졼ȴؿϡɤ⿼ƤӽФ
        äƤޤ Τ褦ʾ硢23 ĤθƤӽФ
        Ÿޤ 

        ѥϡgoto ʸ롼ס try/catch ʸޤ C++ 
        饤ؿ򥤥饤󲽤ޤ -xO4 ٥Ǥ
        ץƥޥˤäƥ饤󲽤뤳Ȥޤ

        礭ʴؿϥ饤󲽤ޤ C++ ѥΥѥ
        ȥץƥޥϤȤˡ饤󲽸δؿΥ
        ޤ ¤ϥȤƤΰŪʿ侩Ǥ 
        ˤΥˤ롢ޤϸϡץ
        ˤĤƵѥݡȤ䤤碌Ƥ

        ۴ؿ֥饹ǺƤʤȤƤ⡢饤
        뤳ȤϤǤޤ ϡ̤Υѥ˥åȤ˥
        饹Ȳ۴ؿκޤޤƤΤɤ򥳥ѥ餬
        ǧǤʤǤ

        ΰΥСǤϡʣ if ʸ return ʸĴؿ
        饤󲽤ǤޤǤ ¤Ϥʤʤ
         ޤ饤ؿФǥեȤΥ¤
        ¤Ƥޤ ץˤäƤϡˤäƥ
        饤󲽲ǽʴؿޤѥ֤Ĺʤꡢ
        ɤΥ礭ʤ뤳Ȥޤ

        C++ 饤ؿΥ饤󲽤̵ˤˤϡ+d 
        ץѤޤ

        Ȥ̤ˡŬ٥뤬⤤ (-xO4) 硢ץƥޥ
        եʤɤη̤˴Ťƴؿ򥤥饤󲽤ޤ 
        Υ饤󲽤ϼưŪǡؿ "inline" Ƥ뤫ɤ
        ˴طʤԤޤ

      2.stdlib ȥ꡼ϡgcc ޤ KAI ȥ꡼®Ǥ
        ѥեޥ󥹤㲼礭ޤ ϤΤǤ礦?
         
        C++ 5.4 ǤϡǥեȤΥȥ꡼饤֥Υѥեޥ
        夷Ƥޤ꤬ˤϡβ򻲹ͤˤƤ
         

        -library=iostreams ץѡ Υץϡɸॹ
        ȥ꡼ǤϤʤֽפ iostreams Ѥޤ Υ
        饹ϸΨŪǤ뤳Ȥ狼äƤޤ ǰʤȤˡ 
        iostreams ѤȤȤϡ stdlib εǽѤǤʤ
        ʤꡢ-library=iostreams ȤäơץΤ򥳥ѥ
        ɬפ뤳Ȥ̣ޤ ޤ iostreams 
        ˤϡɤѹɬפˤʤ뤳Ȥޤ 

        -library=stlport4  -library=iostreams ץλ
         STLport ѡ ɸ⡼ (ǥե) ȸߴ⡼ 
        (-compat) ξǡʤΥѥեޥ󥹤褦Ǥ
         (gcc  50% ) 

                                          : 2004 ǯ 5  27 
    ------------------------------------------------------------------

    Copyright (C) 2004 Sun Microsystems, Inc., All rights reserved. 
    Use is subject to license terms.

