                                                    XVt: 2004 N 5  27 

Sun[tm] Studio 9: C++ FAQ

    ڎ

        A.̃[XŒǉꂽ
        B.o[WApb`AуT|[g
        C.RpČ݊
        D.R[fBOѐff
        E.Cǔ݊
        F.RpC̃ptH[}X̌
        G.s̃ptH[}X̌

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

    A.̃[XŒǉꂽ

      1.ꂼ̃[XŁAǂ̂悤 C++ RpCł邩mF
        Mł@ĂB
  
      2.ŋ Solaris OS Ƀpb`CXg[̂łAR[h
        RpCȂȂ܂BǂĂł?
  
      3.foo.cc t@C̃RpCA܂͑̃\[X̎QƂ̂
        sĂȂɂ炸Afoo.cc ɊւG[x
        o͂܂BĂB
  
      4.-P IvVgpāAOɂĐꂽ foo.i t@C
        RpCƁA`dĂ邱ƂG[b
        Z[WԂ܂BĂB
  
      5.C++ RpC̃vRpCς݃wb_[t@C@\gn
        ߂̂łARpC̃ptH[}Xサ܂Bǂ
        Ăł?
  
      6.ȃt@CɔׂāA傫ȃt@C̃RpCɂ鎞
        ܂BǂĂł?
  
      7.SPARC V9 A[JCuCu𓮓ICuɃNƁA
        G[ɂȂ܂BǂĂł?Sun Studio 8 ł͖肠
        łB
  
      8.uSunWS_cache: Error: Lock attempt failed for SunWS_cachev
        bZ[WԂ錴ĂB
  
      9.WCuXg[Agcc  KAI Xg[ᑬłB
        ptH[}X̒ቺ傫܂B͂̂ł傤 ?
  
     10.J[uld: warning: symbol 'clog' has differing typesv
        ƂxԂ܂BǂĂł?
  
     11.-xarch=v8plus ܂ -xarch=v8plusa tăRpCƁA
        STLport gp}`XbhvONbV܂B
        ǂĂł傤?
  
     12.abs() ɑ΂Ăяo܂łƂӖ̃bZ[W
        RpCԂ܂BǂĂł?
  
     13.ꎞIuWFNg͂j󂳂̂ł傤? 


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

      1.ꂼ̃[XŁAǂ̂悤 C++ RpCł邩mF
        Mł@ĂB 

        ǂ̃RpCɂAg̏񋟂邢̃}NO
        ɒ`Ă܂BRpC̃x_[́A[Xς
        AO`}N肵ē삷悤ɂw͂
        ĂASun ̏ꍇ́A肵JC^tF[XƂĖL
        ܂B
        
        ̃RpCmF@Ƃėǂ̂́AO`}N
        ̗LmFāAprɍo͂鏬ȃvO
        쐬邱ƂłB^vO쐬A-E (܂́A
        RpC̏ꍇ͑IvV) tẴvO
        RpC邱Ƃł܂B
        
        C++ RpC̎O`}NɂẮAwC++ [U[YKC
        hx̍́u}NvQƂĂB̓Iɂ́A
        __SUNPRO_CC ̒l 3  16 iłBŏ̐W[
        [XA2 ڂ̐}Ci[[XA3 ڂ̐}CN
        [X\܂BƂ C++ 5.6  0x560 łB 
        
        ȉɎȎO`}N̓e܂B 
         
        #ifdef __sun
               Sun compiler
        #endif
        #ifdef __SUNPRO_C
               Sun C compiler /* __SUNPRO_C ̒l̓o[Wԍ */
        #endif
        #ifdef __SUNPRO_CC
               Sun C compiler /* __SUNPRO_CC ̒l̓o[Wԍ */
        #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 Ƀpb`𓖂Ă̂łAR[hRpC
        ȂȂ܂BǂĂł? 
        
        ŋ߂̃o[W Solaris Œ񋟂ĂVw֐
        ŁAȑO͐łR[hsɂȂ\܂B
        
        ȑO <math.h> ̊֐ׂ͂double ^p̃o[WłB
        V Solaris wb_[уCuɂ́Afloat  
        long double ^̑d`܂B܂ȌĂяo
        邽߁A^̈֐̌ĂяoŁAIȃLXg
        ǉKvɂȂ邱Ƃ܂Bȉɗ܂B
        
        #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
        
        L Solaris pb`́ASolaris 8  9 p libm pb`
        Ă ANSI C++ ɏ <cmath>  <math.h> 
        CuT|[g񋟂܂B 
        
        Solaris 9 SPARC (pb` 111722-04) 
        Solaris 9 i386 (pb` 111728-03) 
        Solaris 8 SPARC (pb` 111721-04) 
        Solaris 8 i386 (pb` 112757-01) 
        
      3.foo.cc t@C̃RpCA܂͑̃\[X̎QƂ̂
        sĂȂɂ炸Afoo.cc ɊւG[x
        o͂܂BĂB 
        
        wb_[t@C foo.h Ƀev[g錾ꍇAftH
        gł̓RpĆAC++ ̃t@Cgqt@C foo 
        (foo.cAfoo.ccAfoo.CAfoo.cppAfoo.c++) TA
        ́AIɂ̃t@C荞݂܂Bڍׂ́AwC++ [
        U[YKChx́uTemplate Definitions SearchingvQƂĂ
        B
        
        t@C foo.cc ̂悤ɏȂꍇAI 2 
        ܂B
        
           o .h ܂ .cc t@C̖OύXāAΏۂr
             悤ɂB 
           o -template=no%extdef IvVw肷邱ƂɂāA
             ev[g`t@C̎𖳌ɂB
             ÃIvV́AƗev[g`̌
             ׂĖɂ܂BC++ W̃Cuł́ARp
             CƗ`ôƑz肵Ă܂B̂
             ߁AׂẴev[g`𖾎IɎ荞ޕKvA
             Ȃƒ`Ɨfgpł܂B
        
             ev[g`f̂ɏڂéAwC++ [
             U[YKChx 5.2.1  5.2.2 ߂QƂĂB
             wC++ [U[YKChx̍ɁA`Ɨfђ
             `荞݃fĂꏊLڂĂ܂B
        
      4.-P IvVgpāAOɂĐꂽ foo.i t@C
        RpCƁA`dĂ邱ƂG[b
        Z[WԂ܂BĂB 
        
        ftHgł́ARpĆAev[g`Ƃ̐錾
        Ă邱ƂٔF܂Bev[g`f̂ɏڂ
        éAwC++ [U[YKChx 5.2.1  5.2.2 ߂Q
        ĂBwC++ [U[YKChx̍ɁA`Ɨf
        ђ`荞݃fĂꏊLڂĂ܂B
        
        Kvȃev[g̒`Ȃ錾 .h ܂ .i t@Cɂ
        ƁARpC̓ev[g`t@CT܂B.h ܂
         .i t@CƖOŁAgq c  ccACAc++Acpp 
        ꂩ̃t@Cev[g`t@CƂ݂Ȃ܂BC++ }
        jAŐĂ悤ɁAt@C݂ƁA
        IɎ荞܂܂B
        
        foo.cc t@C -P tăRpCāAfoo.i 
        AKvȃev[g̐錾͂邪A`ȂƉ肵܂B
        RpC͒`t@CTAfoo.cc o܂Bfoo.cc 
        t@CIɎ荞܂A`d邱ƂɂȂ܂B
        
        RpC̃ev[g`̌́A-template=no%extdef Iv
        Vw肷邱ƂɂĖɂł܂BȂA
        IvV́AƗev[g`ׂ̌Ėɂ
        BC++ W̃Cuł́ARpCƗ`
        ôƑz肵Ă܂B
        
        ̏ꍇ́A.i t@CRpC킯łAP
        t@CύXāAӂ̖Oɂ܂BƗev[g
        ̃RpC𖳌ɂKv͂܂Bȉɗ܂B
        
                CC -P foo.cc
                mv foo.i foo_prep.i
                CC -c foo_prep.i
        
        -E IvVgpāAOς݃t@C𐶐ꍇA
        ̕@͋@\ȂƂɒӂĂB-E IvV͎
        ܂ꂽt@C̖ŐL^Ƃ邽߁A .cc t@C
        IɌo\܂B
        
      5.C++ RpC̃vRpCς݃wb_[t@C@\gn
        ߂̂łARpC̃ptH[}Xサ܂Bǂ
        Ăł? 
        
        vRpCς݃wb_[gƂɂāARpCԂ
        Zkۏ؂͂܂BvRpCς݃wb_[gp
        ƁAt@C𒼐ڃRpCƂɂ͂ȂI[o[wbh
        ܂BptH[}X̌̂߂ɂ́AvRpC
        菜鑽̏璷vRpCς݃wb_[ɑ݂K
        v܂B
        
        Ƃ΁AvRpC邱ƂŃbg\
        vOƂẮÃVXewb_[o̓Xg[A
        STL wb_[AvWFNgwb_[܂łvO
        ܂Bt@Cɂ́AtRpCR[h܂܂
        邽߂łBꕔ̃wb_[͕荞܂邽߁At@C
        Ŝ if ŜXL΁A璷ȃCN[hōs
        邱Ƃ͉ȂƂ킩܂BʂɁAVXewb_[
        ͐S̃}N܂B
        
        vRpCς݃wb_[gpƂƂ́A\̃t@C
        J 1 ̃t@CJƂӖ܂BR
        g]ȋ󔒂Ɠ悤ɂāAȂ̃CN[h
        菜܂Bwb_[̃}N͎OɓWJ܂BʂɁA
        ƂARpCԂ̑啝ȒZkɂȂ܂B
        
      6.ȃt@CɔׂāA傫ȃt@C̃RpCɂ鎞
        ܂BǂĂł? 
        
        炭̓t@C̃TCYł͂܂Bl錴
        3 ܂B
        
           o t@C̊֐̃TCYƍœKx
             
             œKx̍傫Ȋ֐͏ɎԂAʂ̃
             [KvƂ邱Ƃ܂BR[hōL͈͂ɑ傫ȃ}
             NgpĂꍇA֐A}NWJ
             ɔɑ傫Ȃ邱Ƃ܂B
             
             œKȂ (-xO?  -O? IvVtȂ) ŃRpC
             Ă݂ĂBRpCZԂɏIꍇA
             炭́Aɑ傫Ȋ֐t@C 1 ȏ㑶݂
             ĂāAœKɂȂ̎Ԃƃ[v邱Ƃɂ
             ܂B
             
             ܂ARpCɎgpRs[^ɁARpC
             ŝɏ\ȕ[邱ƂmFĂB
             \ȃ[ȂƁAœKtF[YŎԂ邱
             ܂B
             
           o CC֐
             
             C  C++ ̃CC֐̓}NɎĂāARpC
             Ԃɉe^܂B֐ĂяoCCɓWJ
             ƁAʂ̃R[hɕϊ邱Ƃ܂BRpC
             ́A2 ȏ̏Ȋ֐ł͂Ȃ 1 傫Ȋ֐ɑΏ
             ƂɂȂ܂B
             
             ֐̃CC𖳌ɂƁARpCԂZk
             邱Ƃ΂΂܂BR̂ƂƂāAĂ
             ꍇAĐR[h̎sx͒ቺ܂B
             
             ڍׂ́AwC++ [U[YKChx -xinline сuUsing
             Inline Functionsv̐QƂĂ 
             
           o C++ ̃NXev[g
             
             C++ ev[gw肳ĂꍇARpC͌Ăяo
             ꂽev[gɊÂăR[h𐶐܂B1 s
             \[XR[hɑ΂āA1 ȏ̃ev[g֐̐
             KvɂȂ邱Ƃ܂B܂Aev[ĝ̂
             RpCx啝ɒቺĂ̂ł͂ȂÃ\[
             XR[ȟڂRpCȂ΂ȂȂ
             R[hƂƂłB
             
             Ƃ΁Aȉ̂悤Ȋ֐łɊ܂ޕWCu
             Ɖ肷ƁB\[XR[ĥ̍śA241 
             ֐邱ƂɂȂ܂B
             
             cout << "value = " << x << endl;
        
      7.SPARC V9 A[JCuCu𓮓ICuɃNƁA
        G[ɂȂ܂BǂĂł?Sun Studio 8 ł͖肠܂
        łB 
        
        V9 p̐VftHg̃RpCAhXR[hf́A
        -xcode=abs44 łB́AO -xcode=abs64 ɔׂăptH[
        }Xコ܂BȂA̐VR[hf́A
        ICuł͎gpł܂B̖ɑ΂ 2
        ܂B
        
           o -xcode=pic13 ܂ -xcode=32 tăIuWFNgt@C
             ăRpCB̕@𐄏܂BقڂłA
             K؂ȉłB
        
           o -xcode=abs64 tăIuWFNgt@CăRpC
             B̕@ł́AICuLłȂȂ܂B
             ʂ̃[̈ɃRs[ƂɁAvZXƂɃCu
             Kv܂B̕@́AptH[}
             X̐񂪑傫AVXeLႢŔɒ
             ԎsAvP[Vɑ΂ėLpłB
        
      8.uSunWS_cache: Error: Lock attempt failed for SunWS_cachev
        bZ[WԂ錴ĂB 
        
        ev[gLbVɊւāulock attempt failedvƂG
        [bZ[WԂȌ 2 ܂B
        
           o LbVɑ΂ĕێĂbNȂ`
             RpCُI邩AI邽B̏
             ́AÂo[W̃RpCŔ邱Ƃ܂B
             Vo[WэŐṼpb`ĂꂽÂRp
             Cł́ARpC̏I@Ɋ֌WȂKbN
             悤ɂȂĂ܂BPɃbNt@C폜Ă
             ܂܂񂪁AĂLbVĂ邽߁A
             ƁAɖ肪N܂BłSȕ@́Aev
             [gLbVŜ폜邱ƂłB
        
           o RpCvZXev[gLbVɏ݂s
             ȂBڍׂ́Aumask(1) ̃}jAy[WQƂĂ
             B̓Iɂ́AɃLbV܂̓t@C쐬
             vZX umask ŁALbVɃANZXKv
             鑼̃vZXɂLbVւ݂̏Ă
             Kv܂BfBNg NFS t@CVXeɃ}
             EgĂꍇ́AVXeǂݎ/݃}E
             gKv܂B 
        
      9.WCuXg[Agcc  KAI Xg[ᑬłB
        ptH[}X̒ቺ傫܂B͂̂ł傤 ?
        
        ̖ɂ́ANɐV C++ RpCIv
        V -sync_stdio=no w肷邩Async_with_stdio(false) 
        ֐ւ̌ĂяoǉāAăRpC܂B
        
        stdlib 2.1.1 ̃ptH[}X̍ő̖́AftHg C 
        stdio  C++ Xg[̓Ƃ邱ƂłBcout ւ̂
        o͂A̓sxɃtbV܂BvO 
        stdout ł͂Ȃ cout ɑʂ̏o͂sƁẢߓx̃obt@
        tbVɂāAvO̎s̃ptH[}X傫
        e󂯂邱Ƃ܂BC++ Kił́A̓삪KvƂ
        Ă܂AKׂĂ̎̎dl𖞂Ă킯
        ͂܂B̃vÓAƂȂƖ肪
        ꍇ̗̋łB̃vO͖ɉs̕tuHello 
        beautiful worldvƂso͂̂łB 
        
            #include <iostream>
            #include <stdio.h>
            int main()
            {
                std::cout << "Hello ";
                printf("beautiful ");
                std::cout << "world";
                printf("\n");
            }
        
        Acout  stdout Ɨăobt@OĂ
        ꍇÃvO͊҂ꂽo͂sȂ\܂B
        
        s\t@CăRpCłȂꍇ́ANɐV
        C++ RpCIvV -sync_stdio=no w肵ĂB
        ̃IvV́AvOo͂ÕvO
         sync_with_stdio( ) Ăяo܂B
        
        ăRpC\ȏꍇ́AvOo͂̑O 
        sync_with_stdio(false) ɑ΂Ăяoǉ邱ƂɂāA
        o͂̓ƂKvȂƂw܂Bȉ́AĂяo
        łB
        
                #include <iostream>
                int main(int argc, char** argv)
                {
                        std::ios::sync_with_stdio(false);
                }
        
        sync_with_stdio ɑ΂ĂяóAvO̍ŏ̌Ăяo
        ɂ܂B
        
        -sync_stdio ̏ڍׂ́AwC++ [U[YKChx܂ C++ }
        jAy[W CC(1) QƂĂB
        
     10.J[uld: warning: symbol 'clog' has differing typesv
        ƂxԂ܂BǂĂł? 
        
        vO libm.so.2 Ƌ̓o̓Xg[Cu
        NƁAJ[́AقȂނ̎アV{̃yA
        邱Ƃx܂B̌x͖Ă܂܂B
        
        Solaris 10 ł́AftHg̐wCu libm.so.2 ŁA
        C99 Kiŋ߂Ă悤ɁÃCȗ̖O
        ɂ́AuclogvƂfΐ֐܂܂Ă܂Bɑ΂A
        -compat=4 ܂ -library=iostream w肷邱Ƃɂ C++ 
        ̋̓o̓Xg[gpƁA̖OԂɃobt@
        tWo̓Xg[́uclogvgp܂B(Wo̓X
        g[ɂ́A̖V{͂܂B) 
        
        wb_[уCuāÁuclogvV{
        ͂ꂼÖقɖOύX邽߁A1 ̃vOł̗
        gpł܂BÃV{TÂoCi
        Nł悤ɂɂ́A烉CûꂼŌ
        ̃V{̃XyアV{ƂĕێKv܂B
        
        ̂߁Ao̓Xg[ƐwCu̐錾gp
        ɂɂ́ÃGeBeBŐ錾̂ł͂ȂA
        K؂ȃVXewb_[CN[h܂B
        
     11.-xarch=v8plus ܂ -xarch=v8plusa tăRpCƁA
        STLport gp}`XbhvONbV܂B
        ǂĂł傤? 
        
        XASTLport ɂ́A-xarch=v8plus ܂ -xarch=v8plusa t
        ăRpCƂA}`XbhWoO
        ܂B̃oO͏CĂ܂ȀCɂ STLport 
        wb_[̕ύXƁA STLport IuWFNg̕ύX܂
        Ă܂BȑÕo[W STLport wb_[găRp
        CR[h́AVvOɃNO C++ 5.6 
        pb`𓖂ĂȑÕ[XōăRpCKv܂B
        
     12.abs() ɑ΂Ăяo܂łƂӖ̃bZ[W
        RpCԂ܂BǂĂł? 
        
        C++ Ki̐ 26.5 ł́Aabs ֐̂悤ɑd`邱Ƃ
        ߂Ă܂B
        
           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);
        
        Ȃŋ߂܂ŁASolaris Ŏgpł abs ͏] int ł
        łBǂ̂悤Ȑl^ abs ĂяoĂAĺA
        <stdlib.h> ܂ <cstdlib> CN[hĂ̂ƂāA
        Öقint ^ɕϊAint ł abs Ăяo܂B 
        
        ŋ߂̍XVɂāASolaris wb_[уCu C++ 
        w֐Ɋւ Kiɏ̂ɂȂĂ܂B
        
        Ƃ΁A<stdlib.h> ł͂ȂA<math.h> CN[hāA
        ^̈ abs ĂяoꍇARpĆA3 镂
        _^o[W abs ֐̂ 1 IKv
        ܂Bl͔Cӂ̕_^ɕύXłAɗD悷ϊ
        ܂(Ql: C++ Ki 13.3.3 )B̂߁Å֐Ăяo
        ͂܂ɂȂ܂B܂A܂G[́AC++ Kiɏ
        ĂRpCł΁AǂłԂ܂B
        
        ^̈ abs ֐ĂяoꍇA̓K؂Ȑ錾gp
        悤ɂɂ́AWwb_[ <stdlib.h> ܂ <cstdlib>
        CN[h܂B_^̒l abs Ăяoꍇ́A
        <math.h> ܂ <cmath> CN[h܂B
        
        ȒPȃvO~ȌKƂāA<math.h>  <cmath> CN
        [hꍇ́A<stdlib.h> ܂ <cstdlib> CN[h
        邱Ƃ𐄏܂B
        
        l̂Ƃ́Acos  sqrt Ȃǂ̑̐w֐ɂĂ͂܂܂B
        ݂ Solaris ̃wb_[уCu C++ Kiɏ
        A֐ floatAdoubleA long double ̑d
        `o[W񋟂Ă܂BƂΐ^̒l sqrt Ă
        oꍇAĂ 1 ̃o[W sqrt Ȃ߁A
        RpCsĂ܂BA݂ 3 ̕_
        o[W邽߁AlړI̕_^ɃLXg
        Kv܂B 
        
                double root_2 = sqrt(2); // G[
                double root_2 = sqrt(2.0); // OK
                double x = sqrt(int_value); // G[
                double x = sqrt(double(int_value)); // OK
        
     13.ꎞIuWFNg͂j󂳂̂ł傤? 
        
        RpCꎞIuWFNg쐬闝RƂẮA֋X̂
        Ƃ΁AKł̂Ƃ߂ĂĂ邽߂̂Ƃ
        ܂BƂΊ֐Ԃl͈ꎞIuWFNgŁA^ϊ̌
        ꎞIuWFNgłB
        
        IWi C++ ̋Kł́AꎞIuWFNg ("temp") ́A
        ꂪ쐬ꂽubNI܂ł̊Ԃɂłj󂷂邱Ƃ
        ł܂B C++ RpĆAubN̏I (
        E)  temp j󂵂܂B
        
        Nɂ킽錃čAC++ ψ́Atemp j󂷂ׂ
        uɂČ_ɒB܂B́Atemp 쐬ꂽŜ
        IʒułBʏÄʒúA̎镶Iʒu
        łBꂪAC++ Ki̋KłB
        
        ȂASun  C++ gpĂ鑽̃vOA
        炭ӎ̂ɁAubN̏I܂ temp cĂ邱
        ƂɈˑĂƗ\z邽߁ARpC̃ftHg̓
        ͕ύXĂ܂BȂ킿AftHgł́AꎞIuWFN
        g͍쐬ꂽubN̏ÏʒuŔj󂳂܂B
        
        Kiɏ (temp 쐬ꂽSɏIʒuł
         temp j󂷂) Kvȏꍇ́ARpCIvV 
        -features=tmplife gpĂB
        
        vOŜʂẴIvVgpKv͂܂B
        W[ō쐬ꂽꎞIuWFNǵARpCɂ̃I
        vVLǂɏ]āÃW[̎I
        u܂̓ubNIʒuŔj󂳂܂B


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

    B. o[WApb`AуT|[g

      1.uWvсuvo̓Xg[̈Ⴂ͂Ȃł ? 
        ܂A̖ɊւQlĂB 

      2.ǂ C++ RpCɌ݊̂A@Ă
        B 

      3.Sun Studio 9 Ŏgpł郉CuƂāuFv 
        RogueWave CuĂB 

      4.ǂ̂悤ȃpb`āÃ݂pb`łǂ̂悤Ȗ肪
        ̂𒲂ׂɂ́Aǂ΂悢ł傤 ? 

      5.libC.so.5  libCrun.so.1 ɑ΂pb`͕Kvł傤 ?


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

      1.Wo̓Xg[Ƌo̓Xg[̈Ⴂ͂Ȃł ?
        ܂A̖ɊւQlĂB 

        2 ̃Cu̐ݒƎ܂قȂ܂B Pȓo
        ͂̃vO~OC^tF[X͍Ă܂B A
        [U[Ǝ̃Xg[NX}js[^݂̏ȂǁA
        GȓɂĂ͑傫قȂ܂B

        {o[Ẃuvo̓Xg[CúA C++ 3.x 
         4.x ɕto[Wƌ݊܂B̃[
        Xɕt}jÂقɂÂ悤ȎQl܂B

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

        Wo̓Xg[CuɂẮAC++ Standard Ő
        Ă܂B ̑ɂÂ悤ȎQl܂B 

          o Nicolai Josuttis 
            The C++ Standard Library 
            Addison-Wesley 1999 
            (C++ WCuSʂɊւ`[gA) 

          o Angelika Langer  Klaus Kreft 
            Standard C++ IOStreams and Locales 
            Addison-Wesley 1999 
            (o̓Xg[ƃP[Ɋւ`[gA) 

        Pȓo͂邽߂̃\[XR[h́Aǂ̓o̓Xg
        [ʂĂ܂B ȒPɈڍs邽߂ɁAKiÕwb
        _[ <iostream.h>A<fstream.h>A <strstream.h> W
        o̓Xg[ɑĂ܂B ̃wb_[́A
        ̓o̓Xg[ɂO[ol[Xy[Xƍ錾
        Zbg񋟂܂B̃wb_[gpƁAftHg
        Wo̓Xg[gp܂B̓o̓Xg[g
        p悤ɂɂ́A-library=iostream tăRpC
        уNs܂B

        Ƃ΁ÃR[h́ASun ̃RpCgpċƕW
        ̓o̓Xg[ŋ@\܂BAꕔ̃RpC
        gp܂B 

        #include <iostream.h>

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

        // [U[Ǝ̏o͉Zq
        ostream& operator<<(ostream& os, const myclass& m)
        {
            os << m.k;
            return os;
        }

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

            // [U[Ǝ̏o͉Zqgp
            myclass m(val);
            cout << "Value is " << m endl;
        }

        ̂ꂩ̕@ Sun RpCgpāÃR[h
        RpCAs܂B

        example% CC example.cc  # W[hŕWo̓Xg[gp
        example% CC -library=iostream example.cc  # W[hŋ̓o̓Xg[gp
        example% CC -compat=4 example.cc  # C++ 4.2 ݊[h


      2.C++ RpC̃o[WԂ̌݊͂ǂ̂悤ɂȂĂ܂
         ? 

        ܂A`Ă܂B u݊vƂ́Aso[W
        RpCŃRpCꂽIuWFNgR[h㑱o[W
        ̃RpCŃRpCꂽR[hƃNł邱ƂӖ
        ܂B̏ꍇAŏINōŐṼRpCgpKv
        ܂B

        C++ 4.0A4.1A 4.2 RpC͏݊܂B 
        (C++ 4.2 }jAɋLqĂ悤ɁARpC̃o[
        WԂɂ́uO̕v肪܂)B

        C++ ̃o[W 5.0 - 5.6 ܂ł̃RpĆA݊[h 
        (-compat) ŁA4.2 RpCƏ݊łBC++ 4.2 ƃo[
        W 5.0 - 5.6 Őꂽۂ̃IuWFNgR[hƂ͊S
        Ɍ݊܂A㑱RpCfobO (X^
        u) ͐sfobKƌ݊܂B

        ftHgW[hł́AC++  5.0 - 5.6 ܂ł̃RpC
        ݊܂B ۂ̃IuWFNgR[h͊SɌ݊
        ܂A㑱RpC̔fobO (X^u) ͐
        sfobKƌ݊܂B

      3.Sun Studio 9 Ŏgpł郉CuƂāuFv 
        RogueWave CuĂB 

        Sun ̃RpC̊eo[WpɁAǂ̃x_[ǂ̐i
        ؂Ă̂mɒǐՂ邱Ƃ͂ł܂B āA
        FAQ ɍŐVɈێ̂AˑRƂēԂłB C++ 
        RpC̓o[Wɂăx_[ieXgsȂ
        ǂɂẮÃx_[ɖ₢킹Kv܂

        ASun ̃RpCɕtĂꕔ RogueWave Cu
        ɂẮAo׃o[Wƌ݊邱ƂÖقɕۏ؂
        ܂B

      4.ǂ̂悤ȃpb`āÃ݂pb`łǂ̂悤Ȗ肪
        ̂𒲂ׂɂ́Aǂ΂悢ł傤 ? 

        ipb`̍ŐVɂẮAJҌ̎̃|[^TCg
        mFB
        http://developers.sun.com/prodtech/cc

        ĩpb` http://sunsolve.sun.com _E[hł
        B

      5.libC.so.5  libCrun.so.1 ɑ΂pb`͕Kvł傤 ?

        RpĆÃ[XtɂčŐV SUNWlibC pb`
        Ƃɏoׂ܂B

        ʂɁASolaris[tm] Iy[eBOVXeɂ́ÃC
        u̍ŐVłtĂ܂B A΂΁Ã
        Cuɂ́AoȌCptH[}X̉ǂ̂߂̃pb`
        񋟂܂B pb`͏ɗݐςĂāAɌ
        ł邽߁A񋟂Ă钆łŐṼpb`𗘗p邱Ƃ
        ܂B ̕\́A2002 N 3 ݂̍ŐṼpb` ID 
        Ă܂B

        f[^x[XɍŐṼpbP[W邩mFĂB pb
        P[W̖O SUNWlibC (32 rbg) ܂ SUNWlibCx (64 rb
        g) ł

                    \ 1 libC  libCrun ̃pb`

            pb` ID              Solaris             A[LeN`
                            Iy[eBOVXe

            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. RpČ݊

      1.݊[h (-compat) ̃R[hƕW[h̃R[h݂
        Ƃ͂ł܂ ? 

      2.C++ ܂ C vO F77AF90A܂ F95 vOg
        ݍ킹ɂ́Aǂ΂悢ł傤 ? 

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

      1.݊[h (-compat) ƕW[h̃R[h݂邱Ƃ͂
        ܂ ? 

        Sun ł͍݂𐄏܂BuvOCv⓮Iǂݍ݃Cu
        łĂA̗RAvÕR[h݂̍
        T|[gĂ܂B

          o NXIuWFNg̔zuقȂB

          o ֐̌ĂяoقȂB

          o uO̕vقȂB

          o O@B

          o 2 ̓o̓Xg[IuWFNg𓯂t@CLqqɐ
            Ɩ肪B

        vO 2 ̕ (݊[hƕW[h) ʐMȂ
        ƂłAR[hŗOo(X[)ƁAvO
        ɃNbV\܂B

        󋵂ɂẮA݊[hƕW[h̃IuWFNgt@C
        ܂Ƃ߂ăNł܂B ̖ɂẮARpCɕt
        ĂwC++ ڍsKChxŏڂĂ܂B  1 
        uVoCi̍݁vQƂĂB̃KCh́A 
        http://docs.sun.com ICœł܂B

      2.C++ ܂ C vO F77AF90A܂ F95 vOg
        ݍ킹ɂ́Aǂ΂悢ł傤 ? 

        Workshop 6 update 1 (RpC̃o[W 5.2) ȍ~A
        -xlang={f90|f95|f77} IvVgpł悤ɂȂ܂B
        ̃IvV́ANsɕKvȃCuƂ̃Cu
        ̕Kvȏo𐳊mɊo悤hCoɎw܂B

         -xlang IvV́AC RpCɂ͎gpł܂B C 
        [` Fortran [`gݍ킹ɂ́Acc ŃRpC
        AFortran J[ŃNKv܂B


    D. R[fBOѐff
      1.RpCW̗ONXɂĂ̂܂񍐂
        ̂͂Ȃł ? 

      2.C++ 5.3 Ŕhz֐̃X[wɊւăG[ô
        Ȃł ? 

      3.vONƃev[gCX^X̂
        Ȃł ? CX^X̓ev[gLbVɂ悤
        łB 

      4.+w2 gpĂƂA܂ +w2 +d gpĂȂƂɁA
        ֐͓WJȂƂxbZ[W\̂͂Ȃł
         ? 

      5.-ptr IvVgāÃev[g|Wggp
        ÃvWFNgԂŃ|WgLł܂ ?
        łȂꍇ́Aǂ̂悤ɂ΂悢ł傤 ? 

      6.̂悤ȃbZ[W\邱Ƃ܂B SunWS_cache:
        : uf[^x[XbNĂ܂Bҋ@ł...v
        ͂ǂӖł? ͉ł? IuKvł?
        ǂ΂̃bZ[WoȂ悤ɂł܂ ? 

      7.printf("%s",NULL) ȂZOgǑɂȂ̂ł ? 

      8.sqrt() ̌Ăяo@ɂāAf̋̕̕
        Ȃ܂B ͂Ȃł ? 

      9.NXev[g̃th֐̓CX^XꂸA
        NɃG[ɂȂ܂B C++ 5.0 ł͂̂悤ȂƂ͂
        łB̃o[WŃG[ɂȂ̂͂Ȃł ? 

     10.qɂȂNX܂NX̃o[ɃANZX
        ȂAƂ̂͂Ȃł ? 

     11.sɁupure virtual function call (֐Ăяo)vb
        Z[W\錴͉ł ? 

     12.hNX̉z֐́Aʌ`̈قȂNX̉z֐
        BAƂ̂͂Ȃł ? ̃RpC̏ꍇÃR[h
        ɂ͉肪܂B 

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

      1.RpCW̗ONXɂĂ̂܂񍐂
        ̂͂Ȃł ? 

        Solaris ł́AWwb_[ <math.h> ɁAW Unix ɕKv
        \́uexceptionvp̐錾܂B using 錾܂
        using w߂gp C++ WONXXR[vɓ
        ƁAՓ˂܂B 

        // Example 1

        #include <math.h>
        #include <exception>
        using namespace std; // using 錾
        exception E;  // G[AO܂

        // Example 2:

        #include <math.h>
        #include <exception>
        using std::exception; // using 錾
        exception E;  // G[AOɑ΂鑽d錾
        
        using 錾  using w߂rƁAO͔ɈقȂ
        B̂߁AG[bZ[W͊SɈv܂B

        :
            1.<math.h> ̑ <cmath> gpĂB Solaris
               <cmath> ɂ́AC  C++ KiŎw肳Ă錾
              ܂܂܂B <math.h>  UNIX ŗL̋@\Kvł
              ꍇẢ͎gpł܂B 

            2.<math.h> gpꍇ́Ausing std::exception;ƋLq
              ȂłB I std::exception Lq邩A
              typedef gpĕWONXɃANZXĂB
              ɗ܂B 

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

            3.using namespace std; LqȂłB 
            C++ l[Xy[X std ɂ͔ɑ̖O܂܂邽
            ۂ̃R[hł̎w߂gpƁAAvP[VR[h
            ܂̓T[hp[eB̃CuƏՓ˂\܂
            (C++ vO~OɊւ鏑ЂLł́A using w
            ďȃTvvOɒPĂ邱
            Ƃ܂)B X using 錾AIȏCgp
            ܂B 

      2.C++ 5.3 Ŕhz֐̃X[wɊւăG[ô
        Ȃł ? 

        5.3 C++ RpCVɋ C++ Kł́AhNX
        z֐́A㏑֐eÔ݂eł܂B
        ㏑֐̐邱Ƃ͂ł܂Aɂ߂邱Ƃ
        ł܂B ̗ōlĂ݂ĂB 

        class Base {
        public:
            // int ^̗O̓X[ł邪AȊO̓X[łȂ
            virtual void f() throw(int);
        };
        class Der1 : public Base {
        public:
            virtual void f() throw(int); // ok, w
        };
        class Der2 : public Base {
        public:
            virtual void f() throw(); // ok, 茵
        };
        class Der3 : public Base {
        public:
            virtual void f() throw(int, long); // G[, long ͔F߂Ȃ
        };
        class Der4 : public Base {
        public:
            virtual void f() throw(char*); // G[, char* ͔F߂Ȃ
        };
        class Der5 : public Base {
        public:
            virtual void f(); // G[, OF߂Ă
        };

        ̃R[h́AC++ K̎{sRĂ܂B 

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

        Base::f()  int Ô݂X[悤ɐ錾Ă邽
        ֐ foo ́Aint O̕ߑ\łAÕGXP[v
        eȂƂ錾܂B NɃNX Der5 錾
        lĂ݂܂傤Bł̐錾ŁA㏑֐͔Cӂ̗O
        X[ADer5 |C^ foo ɓnƂł܂B ֐ foo 
        ̃RpCɉR[hɖ肪ȂꍇłA֐ foo ͖
        ɂȂ܂B

      3.vONƃev[gCX^X̂
        Ȃł ? CX^X̓ev[gLbVɂ悤
        łB 

        ev[gLbV́ARpCIuWFNgt@
        CԂ̈ˑ֌WXgۗLAev[gCX^X
        LbVɊ܂܂Ă܂B Ã݂RpĆA
        -instances=extern w肳Ăꍇɂ̂݃ev[gLb
        Vgp悤ɂȂĂ邱ƂɒӂĂBIuWF
        Ngt@Cړ܂͖OύX邩AIuWFNgt@C
        CuɌꍇALbVւ̐ڑ܂B 
        2 ̑֎iɎ܂

          1.IuWFNgt@C𒼐ړIɍŏIfBNgɐ܂
            ev[gLbVfBNgɔzu܂B

            ̗͎gpȂłB 

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

            Ɏ̗gpĂB 

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

            makefile }NŃvZXJvZł܂B

          2.CC -xar gpƁAԓIȃA[JCut@C (.a) 
            ł܂B ꂼ̃A[JCuɂ́AA[JCũIu
            WFNggp邷ׂẴev[gCX^X܂܂
            ܂B ̃A[JCuŏIvOɃN܂B 
            ꕔ̃ev[gCX^X͈قȂA[JCuŏd
            AA[JCuŏdȂ悤ɃJ[܂

            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 gpĂƂA܂ +w2 +d gpĂȂƂɁA
        ֐͓WJȂƂxbZ[W\̂͂Ȃł
         ? 

        C++ RpCɂ́A 2 ނ̃CC܂B p[
        T[ɂčs C++  inline ֐̃CCƁAR[
        hWFl[^ɂčsœK̃CCłB C 
         Fortran RpCɂ́AœK̃CC
        ܂ (1 ̃vbgtH[ł́AׂẴRpCɑ΂
        R[hWFl[^gp܂)B

        C++ RpC̃p[T[́AÖقɂ邢͖I inline Ƃ
        Đ錾ꂽׂĂ̊֐̃CCWJ悤Ǝ݂܂B
         ֐傫ƁAp[T[́A+w2 IvVgpĂ
         ꍇɂx𔭂܂B +d IvV́Ap[T[֐
         CCȂ悤ɂ܂B ̂߁A+d gpƌx
         bZ[W\܂B (܂A-g IvVw肵
         AC++ CC֐̓CC܂)B -xO Iv
         V́Ã^CṽCCɂ͉e^܂B

        œK̃CĆAvOɍE܂B -xO4
        ܂͂荂œKxIƁAR[hWFl[^
        ́A֐\[XR[hłǂ̂悤ɐ錾Ă悤ƂA
        Ă̊֐āAu闘_΁A֐ĂяoC
        CR[hŒu܂B œK̃CC (邢́A
        ֐̃CC̎s) Ɋւ郁bZ[W͉\܂
        B +d IvV́AœK̃CCɂ͉e^
        B

      5.-ptr IvVgāÃev[g|Wggp
        ÃvWFNgԂŃ|WgLł܂ ?
        łȂꍇ́Aǂ̂悤ɂ΂悢ł傤 ? 

        -ptr IvV́Ao[W 5.0 - 5.6 ł̓T|[gĂ
        Bo[W 4.2 Œ񋟂Ă܂AK[U[
        ̊҂ǂɋ@\A̖𔭐Ă܂B

        ŗǂ̃AhoCX́ÃvWFNgԂŃ|WgL
        ƂłB |WgLƁA}Ȃقǐ[
        肪\܂B 1 ̃vWFNg 1 ̃f
        BNgŃRpCĂB ʂ̃vWFNg̃o
        Ciɂ͕ʂ̃fBNggpĂB

        o[W 5.0 ȍ~ARpĆAIuWFNgt@C
        ƓfBNgɃev[g|Wgi[܂B 1 
        ̃vWFNgɕ̃|Wggpꍇ́A֌W郊
        |Wgi[fBNgɃIuWFNgt@C쐬
        B NAIuWFNgt@CɊ֌W郊|
        Wgɑ΂āAIɃev[gCX^X̌s
        ܂B RpCIvV͕Kv܂B

      6.̂悤ȃbZ[W\邱Ƃ܂B SunWS_cache:
        u: f[^x[XbNĂ܂Bҋ@ł...v 
        ͂ǂӖł ? ͂Ȃł? uKvł?
        ǂ΂̃bZ[WoȂ悤ɂł܂ ? 

        ev[ggpvORpCƂɁA
        SunWS_cache/CC_state ̃RpCԏ̍XVKvȏꍇ
        RpĆAK SunWS_cache o̓fBNgbN܂
        ev[ggp镡̃vZXfBNgŃRp
        C悤Ƃꍇɂ́Ax 1 ̃vZXbN
        擾܂B

        o[W 4.2A5.0A 5.1  C++ RpĆAbN
        ҂̃vZXƂ͕KA uSunWS_cache: : f[^
        x[XbNĂ܂Bҋ@ł...v ƂbZ[W
        o͂܂B ̃bZ[W͒Pɏʒm邽߂̂̂ł
        AĂB ̃bZ[ẂAʂ̃RpC
        vZXf[^x[XbNƂƂӖĂ܂B
        ̕ʂ̃WuIƁÃ݂Wus܂B dmake
        gpĂ邽߂ɁÃbZ[Woƍl܂B 
        ̃bZ[WoȂ悤ɂ邱Ƃ͂ł܂B ŐV C++ 
        5.2 pb`AC++ 5.3 RpCA5.4 RpCA 5.5 R
        pCł́Aʂ̃bN̗pĂÃbZ[W
        o܂B

    7.printf("%s",NULL) ȂZOgǑɂȂ̂ł ? 

        AvP[V̒ɂ́ANULL |C^͋󕶎ւ̃|C
        ^ƓȂ΂ȂȂƌĔFĂ̂
        ܂B ̃AvP[Vł́ANULL |C^AN
        ZXƃZOgᔽ܂B

        ̗RɂA *printf() ̊֐t@~ɂ NULL |C
        ^̃`FbN@\܂B ꂾɌ܂񂪁A
        悤ȂƂ܂B

            1.`FbN@\҂ƁAS^B vO
              }ɁAprintf() ւ NULL |C^n܂
              Ǝv܂Ă܂܂B

            2.vO}ڐÂȂR[hƂB 
              ANSI CAXPG3AXPG4ASVID2A SVID3 ł́A
              printf("%s", pointer) ɂ NULL ŏI镶̔zւ 
              pointer |CgȂ΂ȂȂƋK肳Ă܂B

            3.fobOȂB vO} NULL |C^
              printf() ɓnĂvORAɓ̂ł΁A
              fobKgp΁Asȃ|C^w肵 printf()
              ĂяoȒPɌoƂł܂B A 
              printf()  "(NULL |C^)" Əo͂邱ƂɂA
              ̃oO\ɂꍇǍŐisق̃vO
              ́Aۂ̃f[^~ƂɁA
              "(NULL |C^)" ߂悤Ƃł傤B ̎_
              ł́Aۂ̖肪ǂɉBĂ邩f邱Ƃ͕s\
              ܂B 

        NULL |C^ *printf ɓnAvP[Vꍇ́A
        P[V 0 ɒl 0 ݒ肷邽߂̃JjY񋟂
        LIuWFNg /usr/lib/0@0.so.1 gp邱Ƃł܂B
        ̃CúANULL |C^̌^ɂႢɊ֘A邷ׂ
        ̃G[}XN̂ŁÃCúAR[hC
        ł̈ꎞIȉƂĂ̎gpɌ肵ĂB

      8.sqrt() ̌Ăяo@ɂāAf̋̕̕
        Ȃ܂B͂Ȃł ? ͂Ȃł ?

        ̊֐̎́AuC99 csqrt Annex G dlvŋK肳Ă܂
        Ƃ΁ÃR[h̏o͂ĂB

        complex sqrt (3.87267e-17, 0.632456) 
        float sqrt (3.87267e-17, -0.632456)
        
        1.݊[h libcomplex gp: 
        
        #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.W[h libCstd gp: 

        #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 ֐́Aatan2 gpĎ܂B̗
         atan2 gp邱ƂɂċN̂łB
        ̃vȌo͈͂ȉ̂ƂłB 

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

        1 ߂̗ł́Aatan2 ̏o͕͂̐ɂȂA2 ߂̗ł͐
        łB ́Aŏ̈Ƃ -0.0 ܂ 0.0 ̂ǂ炪n
        邩ɂ܂B 
          
        #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.NXev[g̃th֐̓CX^XꂸA
        NɃG[ɂȂ܂B C++ 5.0 ł͂̂悤ȂƂ͂܂
        łB̃o[WŃG[ɂȂ̂͂Ȃł ?

        ̃eXgP[X́AC++ 5.0 RpCł́AG[ȂɃRp
        CуNs܂Aȍ~̃o[W̃RpC
        ́AN^CG[܂B 

        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
        
        KiɂƁÃeXgP[X͖łB _͈ȉ̐錾
        ɂ܂
 
        friend ostream& operator (ostream&, const TList&);
        
        ̐錾́Ãev[gCX^XQƂĂ܂
        
        C̎QƂ́Ath錾 1 ӏŔF\łƂ
        Aev[g錾ƈv܂B th錾ev[
        gƈvɂ́Ath錾ev[g֐ƂĐ錾
        邩A܂͖OCKv܂B 
        
        ǂ̕@łAev[gp̐錾́Ath錾 1 
        ŔF\łKv܂B 
        
        ܂Ath錾̓ev[gQƂ܂񂪁A֐Ăяo
        ɂƂv֐錾܂B (ق̓_œ̂ł
        ΁Aev[g֐ev[głȂ֐̂̕
        ƌ܂)B 
        
        ̃R[h͗LłB 

        template <class T> class TList; 
        // ŁAoperator<< ev[g錾ł

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

        template <class T> 
        class TList {
        public :
          // ֐̃XR[vCɒ
          friend ostream& ::operator (ostream&, const TList&);
        };

     10.qɂȂNX܂NX̃o[ɃANZX
        ȂAƂ̂͂Ȃł ? 
         
        class Outer {
            typedef int my_int;
            static int k;
            class Inner {
                my_int j;     // G[Amy_int ɂ̓ANZXłȂ
                int foo() {
                        return k; // G[Ak ɂ̓ANZXłȂ
                        }
                };
        };
         
        ARM  C++ WɂƁAqɂȂNX́A܂
        NX̃o[ɓʂɃANZX邱Ƃ͂܂B my_int 
         k  Outer ŔJȂ̂ŁAOuter ̃th
        o[ɃANZXł܂B qɂȂNXthɂ
        ߂ɂ́ANXOĐ錾ĂthɂKv
        ܂Bȉɗ܂B 
        
        class Outer {
            typedef int my_int;
            static int k;
                //  2 sNX`̑Oɒǉ
            class Inner;  
            friend class Inner;

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

     11.sɁupure virtual function call (z֐Ăяo)v
        bZ[W\錴͉ł ?

        vOɁAG[ƕKAupure virtual 
        function call (֐Ăяo)vbZ[W\܂B 
        ̃G[́A 2 ̂ǂ炩̏ꍇɋN܂B 
        
          1.̃G[́AۃNX̃RXgN^܂̓fXgN^
            AO֐Ɂuthisvp[^nƂɂĔ
            ܂B \zєj󎞂ɁAuthisv́ARXgN^
            ̓fXgN^g̃NX̌^AŏIIɍ\z
            NX̌^͎܂B ŏz֐̌ĂяoI
            邱Ƃł܂B ̗ōlĂ݂ĂB 
          
            class Abstract;

            void f(Abstract*);

            class Abstract {
            public:
                    virtual void m() = 0; // z֐
                    Abstract() { f(this); }   // RXgN^ "this" n
            };

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

            uAbstractvRXgN^ f ĂяoƁA
            uthisv́uAbstract*v^ƂȂA֐ f ͏z֐ m 
            ĂяoƂ܂B 

          2.IȏCqws킸ɒ`z֐Ăяo
            ƂꍇɂÃG[N邱Ƃ܂B {
            ɏz֐w肷邱Ƃ͂ł܂AĂяoɂ͏C
            ĂяoƂł܂B 

            class Abstract {
            public:
                    virtual void m() = 0; // {̂͌Œ񋟂
                    void g();
            };

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

            void Abstract::g()
            {
                    m(); // G[Az m ĂяoƂĂ
                    Abstract::m(); // OKAĂяo͊SɏCĂ
            }

     12.hNX̉z֐́Aʌ`̈قȂNX̉z֐
        BAƂ̂͂Ȃł ? ̃RpC̏ꍇÃR[h
        ɂ͉肪܂B 

        C++ ̋Kł́Ad`̓XR[vł̂ݔF߂AXR[v
        ͔̂F߂܂B NX́AhNX̃XR[
        v芪XR[vɂƍl܂B ̂߁AhN
        XŐ錾ꂽÓANX̂֐BA
        d`ł܂B ̊{I C++ ḰAARM 
        B 

        ق̃RpCAُ\ȂƂĂAɂ葹
        Q܂BȂȂAR[h́A҂Ƃɂ͓삵Ȃ
        łB Sun ̃RpĆÃR[h󂯕tƂɌx
        \܂B (ȃR[hłA炭҂ǂɂ͓
        삵܂B) 

        d`ꂽZbgɊNX֐܂߂ꍇ́AN
        X֐݂̃XR[vɓ邽߂ɎKv܂B
        ftHg̕W[hŃRpCsĂꍇ́A錾̎g
        pǉł܂B 

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

        class Derived : public Base {
        public:
                using Base::foo; // NX֐𑽏d`Zbgɒǉ
                virtual double foo(double); // NXo[Wu


    E. Cǔ݊

      1.S C++ WCu (stdlib) ̓@Ă
        B 邢́A݂ libCstd T|[gĂȂ@\ɂ́A
        ǂ̂悤Ȃ̂܂ ? 

      2.C++ W̃ev[gCu (STL) KvłB ǂœ
        ł̂ł傤 ? ݊[h (-compat) p̂̂͂̂ł
        傤 ? 

      3.libCstd ŎꂽWCu@\ɂ͂ǂ̂悤Ȃ̂
         ? 

      4.WCű@\邱ƂŁAǂ̂悤ȉê
        傤 ? 

      5.WXg[ŋ@\ tools7 Cuo[W͂܂
         ? 邢 tools8 ͂܂Ȃł悤ɂȂ̂ł傤
         ? 

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

      1.S C++ WCu (stdlib) ̓@Ă
        B 邢́A݂ libCstd T|[gĂȂ@\ɂ́A
        ǂ̂悤Ȃ̂܂ ? 

        ̃[Xɂ́ASTLport  Standard Library ̃o[W
        4.5.3 IvV̕WCuƂĊ܂܂Ă܂B
        STLport  C++ KiɌɏĂȂAʓIȊg@\
        ێĂ܂B AftHgŎgpWCu
        Ƃ̃oCi݊͂܂B

        ݂ libCstd ́Ao[W 5.0  C++ RpCpɊJ
        ܂B ̃o[ẂANX̃o[Ƃăev[
        gT|[gĂ܂B WCüꕔɂ́Ao[
        ev[gKvłÂƂ͈ꕔ@\邱Ƃ
        ܂B ͓ɁAÖق̌^ϊ\ɂRXgN^
        ev[gReiNXɂċN܂B ̏ꍇ
        ́AƂă\[XR[hɖIȌ^ϊLqKv
        ܂B

        o[W 5.1 ȍ~AC++ RpC̓NX̃o[Ƃ
        ev[gT|[gĂāAKiɏCugp
        ł܂B \[XƃoCix̌݊𑹂ȂƂȂC
        uXV邱Ƃ͂łȂ߁ATł́A 
        libCstd oׂĂ܂B

        gnu  SGI  Web TCgł́ApubNł̕WCuz
        zĂ܂B܂ARogueWaveADinkumware Ȃǂ̃x_[
        Cuw邱Ƃł܂B STL ɂẮA̎
        QƂĂB

      2.C++ W̃ev[gCu (STL) KvłB ǂœ
        ł̂ł傤B ݊[h (-compat) p̂̂͂̂
        傤 ? 

        C++ RpC͌݁ASTLport  Standard Library o[
        W 4.5.3 T|[gĂ܂BftHg̃Cu͌
        ݂ libCstd łASTLport iɎgpł悤ɂ
        ܂B ̃[Xɂ́AÓIA[JCu libstlport.a Ɠ
        ICu libstlport.so ̗܂ł܂B 

        ̃RpCIvVw肷ƁAlibCstd 𖳌ɂ 
        STLport gpł܂B

        -library=stlport4

        ftHg C++ WCu libCstd  STLport ̗ 
        STL ܂ł܂B ʂ̃o[W̕WCugpł
        ܂A댯AǍDȌʂۏ؂ł܂B

        ʂ STL vOCɂ́A -library=no%Cstd IvV
        gpāARpCۂɎgpwb_[t@CуC
        u悤ɂ܂B p̃Cuɐp
         iostreams ȂAW iostreams ̑Ɂu]v
         iostreams gpłꍇ́AR}hs -library=iostream
        ǉ܂B ڍׂȎ菇ɂẮARpCɕtwC++
        [U[YKChx́uC++ WCu̒uvQƂ
        B ̃KCh́Ahttp://docs.sun.com IC
        ł܂B

        ̃[Xł́A-compat [hɑΉWCu@\
        񋟂Ă܂B T[hp[eB̃Cu (LTLport Ȃ) 
         -compat [hpɍ\łꍇ܂Ã[X
        ͂̂悤ȍ\T|[g܂B
        
      3.libCstd ŎꂽWCu@\ɂ͂ǂ̂悤Ȃ̂
         ? 

        WCúA (C++ 5.0 ł) RpCɃo[e
        v[gѕ̓ꉻKvƂ@\T|[gɍ\
        zꂽ̂łB ̋@\ C++ 5.1 ȍ~Agp\ł
        WCuŗLɂ邱Ƃ͂ł܂B͉݊
        ێ邽߂łBĹAe@\ŖɂA̋@\
        ꂽ@\XgłB

        o ɂꂽ@\: o[ev[g֐

          + <complex>  complex NX: 

            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 NX:

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

          + <locale>  locale NX:

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

          + <memory>  auto_Ptr NX:

            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 NX: 

            o[ev[g̃\[g

          + قƂǂ̃ev[gNX: 

            ev[gRXgN^

        o ɂꂽ@\: o[ev[gNX

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

        o ɂꂽ@\: IɓꉻĂ֐ev[g
          ̑d`

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

          + mapAmultimapA setAmultisetAbasic_stringAvectorA
            reverse_iteratorA istream_iterator NX̏ꍇ:

            bool operator!= ()

          + mapAmultimapA setAmultisetAbasic_stringAvectorA
             reverse_iterator NX̏ꍇ:

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

          + mapAmultimapA setAmultisetAbasic_stringA vector
          NX̏ꍇ:

            void swap()
         
        o ɂꂽ@\: ftHg̃p[^gev[g
          NX̕ꉻ

        <algorithm> ł́Ãev[g֐ (񃁃o[) ̓T|[g
        ܂B

        count(), count_if()

        <iterator> ł́Ãev[g̓T|[g܂B

        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.WCű@\邱ƂŁAǂ̂悤ȉê
        傤 ? 

        C++ Kił͐ȃR[hRpCȂƂ܂B

        Ƃ悭̂́AyȂ 1 vf const ł̂ɁA
        悤ɂ͐錾ĂȂ}bv쐬ĂꍇłB 
        o[RXgN^ev[ǵAKvɉÖق pair<T, U> 
         pair<const T, U> ɕϊ܂B ARXgN^
        ߂ɁAϊꂸɁARpCG[ɂȂ܂B

        }bṽyȂ 1 vfύX邱Ƃ͂łȂ߁A
        ȒPȉ́AyA^쐬ƂɖI const gp
        邱ƂłB Ƃ΁Apair<int, T> ł͂Ȃ 
        pair<const int, T> gp܂B܂Amap<int, T> ł͂Ȃ 
        map<const int, T> gp܂B

      5.WXg[ŋ@\ tools7 Cuo[W͂܂
         ? 邢 tools8 ͂܂Ȃł悤ɂȂ̂ł傤
         ? 

        ͂A܂BAC++ 5.3A5.4A5.5  5.6 ݂̂łB
        -library=rwtools7_std R}hgpẴCuƃN
        ĂB

        RogueWave  Tools.h++ ̋@\ύXĂA݂ł 
        SourcePro ïꕔƂĂ̂ݒ񋟂Ă܂B ̂悤ȗR
        ATools.h++ version 8 ݂͑܂B


    F. RpC̃ptH[}X̌

      1.o[W 4.2 ƔׂāAo[W 5.0  5.1 ̃RpC
        ̃RpCԂ͑啝ɒȂĂ܂B A̖
        ̂ł傤 ? 

      2.o[W 4.2 ̃RpCƔׂăoCĩTCYȂ
        Ȃ܂B ̖̉͂̂ł傤 ? 

      3.1 ̃RpCvZX𕡐̃vZbTɕUłł傤
         ? ʓIɁA}`vZbT (MP) VXe̕RpC
        ̃ptH[}X͏ɗǂ̂ł傤 ? 

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

      1.o[W 4.2 ƔׂāAo[W 5.0  5.1 ̃RpC
        ̃RpCԂ͑啝ɒȂĂ܂B A̖
        ̂ł傤 ? 

        5.1 ̃pb` 01Ao[W 5.2A5.3A5.4A5.5A5.6 ŁA啝
        RpCԂP܂BRpC̃ptH[}Xɖ
        łȂꍇA̐ɗӂĂB

            a.ɒ[ȏꍇACC͖cȎԂ錴ɂȂ
            B -xO4 ܂ -xO5 ̂ꂩ̃IvVgpƁA
            R[hWFl[^̊֐IɃCC
            ܂B -xO3 ̂悤ȒႢœKxgpKv邩
            ܂BIveB}CU֐IɃCC
            Ȃ悤ɂɂ́A-xinline IvVgpł܂

            b.傫Ȋ֐̖IȃCC𖳌ɂ܂B I
            ȃCC̏ڍׂɂẮAȉQƂĂB

      2.o[W 4.2 ̃RpCƔׂăoCĩTCYȂ
        Ȃ܂B ̖̉͂̂ł傤 ? 

        -g IvVŃRpCsƁAo[W 5.0 RpC
        ev[g̃fobOp̑ʂ̏o߁AoCi
        ̃TCY傫Ȃ܂B o[W 5.1 ł́A̎ނ
        vOɂāAfobÕTCY͑啝ɏk
        ܂B 5.2A5.3A5.4A5.5A5.6 RpCł́Aɉǂ
        ȀꍇɁAoCiTCY̏k 25%  50% 
        ȂĂ܂B ǂ́AR[hŖOԂev[gA
        ̌pxNXKwgpĂꍇɓɌ
        łB

     3. 1 ̃RpCvZX𕡐̃vZbTɕUłł傤
         ? ʓIɁAɃ}`vZbT (MP) VXe̕Rp
        C̃ptH[}X͏ɗǂ̂ł傤 ? 

        RpĈ̂̓}`XbhĂ܂B A
        RpC 1 ̃RpCŏɑ̑̃vZX𓯎
        삳邽߁AMP VXe̕ptH[}X̌҂
        ܂B

        dmake (RpCɕtĂc[ 1 ) gpƁA
        ̃RpC𓯎Ɏsł܂B 


    G. s̃ptH[}X̌

      1.C++ ́A"inline" L[[h̕t֐ɃCC
        ̂ł傤 ? 邢́Â悤ɋLqƂĂACC
        Ȃ֐̂́AǂĂł傤 ? 

      2.stdlib Xg[́Agcc ܂ KAI Xg[ᑬłB 
        ptH[}X̒ቺ傫܂B ͂̂ł傤?

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

      1.C++ ́A"inline" L[[h̕t֐ɃCC
        ̂ł傤 ? 邢́Â悤ɋLqƂĂACC
        Ȃ֐̂͂ǂĂł傤 ? 

        {IɁARpĆAinline 錾w߂Ƃ݂ȂÂ悤
        錾ꂽ֐CC悤Ƃ܂Bo[W 5.1 
         5.6 ܂ł̃RpCł́ACCASYǂ
        A葽̍\𗝉悤ɂȂĂ܂B  A
        łA\𗝉łȂP[X݂܂BP[X
        Ɏ܂B

        o[W 5.2 - 5.6  C++ RpCł́AقƂǎs
        Ƃ̂Ȃꕔ֐Ăяo͓WJ܂B̕ύX́ARp
        CxAo̓R[hTCYAюsx̋ύtƂŖ
        ܂B

        Ƃ΁AÓIȕϐŎgp鎮 1 xs
        ߁Å֐Ăяo͓WJ܂B CC֐ 
        func ́AÓIϐ̏ŌĂяoƁAWJȂ
        Ƃ邱ƂɒӂĂBق̏ꏊŃCCꂽ
        ܂܂łB lɁAOnh̊֐ĂяóA
        R[hɂ߂ɎsȂ̂ŁAWJȂ\܂

        ċA֐́Aŏ̌Ăяoxɑ΂Ă̂݃CC
        B RpĆAċA֐̌Ăяo܂ɃCC
        ł܂B ݂̎́ACCĂCӂ̊֐
        ̏Ăяo̎_Œ~܂B

        ƂāAȊ֐ɑ΂ĂяołCC
        Ƃ܂B ̗ŔAWJ̍vTCY傫
        ƂƂłB Ƃ΁Afunc1  func2 ĂяoAfunc2 
        func3 ĂяoAƂ悤ȏꍇ܂B ̊֐
        āAċAIȌĂяo͂ȂꍇłARpC炷
        ׂĂWJꍇɂ́AWJ̃TCY̍v傫\
        ܂B

        ̕Wev[g֐́Aǂ[Ăяo
        `F[Ă܂B ̂悤ȏꍇA2A3 ̌Ăяox
        WJ܂B 

        RpĆAgoto A[vA try/catch ܂ C++ 
        CC֐CC܂B A-xO4 xł
        IveB}CUɂăCC邱Ƃ܂B

        傫Ȋ֐̓CC܂B C++ RpC̃RpC
        ƃIveB}CU͂ƂɁACC̊֐̃TCYɐ
        ܂B ̐̓TƂĂ̈ʓIȐłB 
        ɂ̃TCYɂ߂A܂͌ꍇ́AIvV
        ɂċZpT|[gɖ₢킹ĂB

        z֐TuNXōĒ`ĂȂƂĂACC
        邱Ƃ͂ł܂B ́Aʂ̃RpCjbgɃTu
        NXƉz֐̍Ē`܂܂Ă̂ǂRpC
        FłȂ߂łB

        ȑÖꕔ̃o[Wł́AG if  return ֐
        CCł܂łB A̐͂ȂȂ
        B ܂ACC֐ɑ΂ftHg̃TCY
        aĂ܂B vOɂẮACɂăC
        C\Ȋ֐܂ARpCԂȂA
        R[h̃TCY傫Ȃ邱Ƃ܂B

        C++ CC֐̃CCSɖɂɂ́A+d I
        vVgp܂B

        Ƃ͕ʂɁAœKx (-xO4) ꍇAIveB}CU
        At[Ȃǂ̌ʂɊÂĊ֐CC܂B 
        ̃CC͎IŁA֐ "inline" 錾Ă邩ǂ
        Ɋ֌WȂs܂B

      2.stdlib Xg[́Agcc ܂ KAI Xg[ᑬłB
        ptH[}X̒ቺ傫܂B ͂̂ł傤?
         
        C++ 5.4 ł́AftHg̃Xg[CũptH[}X
        サĂ܂B肪ꍇɂ́ẢQlɂĂ
        B 

        -library=iostreams IvV̗pB ̃IvV́AWX
        g[ł͂Ȃu]v iostreams gp܂B ̃N
        X͌Ił邱Ƃ킩Ă܂B cOȂƂɁA] 
        iostreams gpƂƂ́A stdlib ̋@\płȂ
        ȂA-library=iostreams gāAvOŜRpC
        Kv邱ƂӖ܂B ܂A] iostreams gp
        ɂ́Aꕔ\[XR[h̕ύXKvɂȂ邱Ƃ܂B 

        -library=stlport4  -library=iostreams IvV̎w
         STLport ̗pB W[h (ftHg) ƌ݊[h 
        (-compat) ̗ŁAȂ̃ptH[}X悤ł
         (gcc  50% ȓ)B 

                                          XVt: 2004 N 5  27 
    ------------------------------------------------------------------

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

