                                                XVt: 2003 N 3  1 

 Sun[tm] ONE Studio 8: C++ FAQ

     ڎ

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

       B. RpČ݊

       C. R[fBOѐff

       D. Cǔ݊

       E. RpC̃ptH[}X̌

       F. s̃ptH[}X̌

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

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

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

       3. Sun Open Net Environment (ONE) Studio 8 Ŏ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̐ݒƎ܂قȂ܂BPȓo
          ͂̃vO~OC^tF[X͍Ă܂B A
          [U[Ǝ̃Xg[NX}js[^݂̏ȂǁA
          GȓɂĂ͑傫قȂ܂B

          {o[Ẃuvo̓Xg[CúAC++ 3.x
           4.x ɕto[Wƌ݊܂BRpC
          ɕ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
               (A tutorial on the entire C++ standard library)

             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ƍ錾Z
          bg񋟂܂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()
          {
              // coutAcin 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;}

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

          ܂A`Ă܂Bu݊vƂ́Aso[W̃R
          pCŃ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ɓoꂷRpC̃o[WԂɁuO
          ̕v肪܂)B

          ݊[h (-compat) ɓĂ C++ 5.0A5.1A5.2A5.3A
          5.4A 5.5 RpĆA4.2 RpCƏʌ݊
          ܂BC++ 4.2 ƁAo[W 5.0A5.1A5.2A5.3A5.4A
           5.5 Őꂽۂ̃IuWFNgR[hƂ͊SɌ݊
          ܂A㑱RpCfobO (X^u) ͐
          sfobKƌ݊܂B

          ftHgW[h C++ 5.0A5.1A5.2A5.3A5.4A
          5.5 RpC͏݊܂Bۂ̃IuWFNgR[
          h͊SɌ݊܂A㑱RpC̔fobO
           (X^u) ͐sfobKƌ݊܂B

       3. Sun Open Network Environment (ONE) Studio 8 Ŏgpł郉C
          uƂāuFv RogueWave CuĂ
          B

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

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

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

          ĩpb`ɊւŐVɂẮAƂǂ Hot News 
          Web y[WɃANZXĂ݂ĂB
          ( http://sun.co.jp/software/sundev/suncc/hotnews.html) ɃANZ
          XĂ݂ĂB

          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[eBOɂ́ÃCu
          ̍ŐVłtĂ܂B A΂΁ÃC
          uɂ́AoȌCptH[}X̉ǂ̂߂̃pb`
          񋟂܂Bpb`͏ɗݐςĂāAɌ
          ł邽߁A񋟂Ă钆łŐṼpb`𗘗p邱
          𐄏܂B̕\́A2002 N 3 ݂̍ŐṼpb` ID 
          Ă܂B

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

                        \ 1:libC  libCrun ̃pb`

               pb` ID           Solaris           A[LeN`
                          Iy[eBOVXe

               106327-18              7              SPARC (R);/v8

               106300-19              7              SPARC/v9

               106328-17              7              i386

               108434-11              8              SPARC/v8

               108435-11              8              SPARC/v9

               108436-10              8              i386

               111711-04              9              SPARC/v8

               111712-04              9              SPARC/v9

               111713-02              9              i386

     B. 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݂邱Ƃ͂
          ܂ ?

          Tł͍݂𐄏܂BuvOCv⓮Iǂݍ݃C
          ułĂ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 F77AF90AF95 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

     C. R[fBOѐff

       1. WONXɂĂ܂ȃ|[g񎦂̂͂Ȃ
          ł ?

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

       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:
          : f[^x[XbNĂ܂Bҋ@ł...v
          ǂӖł ? ͂Ȃł ? uKvł
          ? ǂ΂̃bZ[Wo͂Ȃ悤ɂł܂ ?

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

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

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

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

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

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


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

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

          Solaris ł́AWwb_[ ɁAW Unix ɕKv \
          uexceptionvp̐錾܂Busing 錾܂ using w
          gp C++ WONXXR[vɓƁAՓ˂
          ܂B

          //  1

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

          //  2:

          #include <math.h>
          #include <exception>
          using std::exception; // using w
          exception E;  // G[, Oɑ΂鑽d錾

          using 錾  using w߂rƁAO͔ɈقȂ
          ܂B̂߁AG[bZ[W͊SɈv܂B

          F

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

            2. <math.h> gpꍇ́A using std::exception; ƋLq
               ȂłB I std::exception Lq
               Atypedef 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܂܂邽
               ߁Aۂ̃R[hł̎w߂gpƁAAvP[V
               R[h܂̓T[hp[eB̃CuƏՓ˂\
               ܂B(C++ vO~OɊւ鏑ЂLł́A
                using w߂ďȃTvvO
               PĂ邱Ƃ܂)BX using 錾A
               Iȏ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, same specification
          };
          class Der2 : public Base {
          public:
                  virtual void f() throw(); // ok, more restrictive
          };
          class Der3 : public Base {
          public:
                  virtual void f() throw(int, long); // error, can't allow long
          };
          class Der4 : public Base {
          public:
                  virtual void f() throw(char*); // error, can't allow char*
          };
          class Der5 : public Base {
          public:
                  virtual void f(); // error, allows any exception
          };

          ̃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[悤ɐ錾Ă邽
          ߁A֐ foo ́Aint O̕ߑ\łAÕGXP[v
          eȂƂ錾܂BNɃNX Der5 錾
          ꍇlĂ݂܂傤Bł̐錾ŁA㏑֐͔Cӂ
          OX[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Ɋ܂܂Ă܂BIuWFNgt@Cړ܂
          OύX邩AIuWFNgt@CCuɌ
          ALbVւ̐ڑ܂B2 ̑֎iɎ
          ܂B

             o IuWFNgt@C𒼐ړIɍŏIfBNgɐ
               Bev[gLbVfBNgɔzu
               B

               ̗͎gpȂłB

               CC -c f1.cc
               mv f1.o /new/location/for/files

               Ɏ̗gpĂB

               CC -c f1.cc -o /new/location/for/files/f1.o

               makefile }NŃvZXJvZł܂B

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

               example% CC -c f1.cc f2.cc f3.cc
               example% CC -xar f1.o f2.o f3.o -o temp1.a
               example% CC -c f4.cc f5.cc f6.cc
               example% CC -xar f4.o f5.0 f6.0 -o temp2.a
               example% CC -c 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܂Bp[
          T[ɂčs C++  inline ֐̃CCƁAR[
          hWFl[^ɂčsœK̃CCłBC 
           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 IvV
          ́Ã^CṽCCɂ͉e^܂B

          œK̃CĆAvOɍE܂B-xO4
          ܂͂荂œKxIƁAR[hWFl[
          ^́A֐\[XR[hłǂ̂悤ɐ錾Ă悤ƂA
          ׂĂ̊֐āAu闘_΁A֐Ăяo
          CCR[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ǂ̂悤ɂ΂悢ł傤 ?

          o[W 5.0A5.1A5.2A5.3A5.4A 5.5 ł́A-ptr I
          vV̓T|[gĂ܂Bo[W 4.2 Œ񋟂
          ܂AK[U[̊Ғʂɋ@\A̖
          𔭐Ă܂B

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

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

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

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

          o[W 4.2A5.0A 5.1  C++ RpĆAbN
          ҂̃vZXƂ͕KAuSunWS_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 RpCł́Aʂ̃bN̗pĂÃb
          Z[W͏o܂B

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

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

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

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

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

             o fobOȂBvO} NULL |C^
               printf() ɓnĂvORAɓ̂ł΁A
               fobKgp΁Asȃ|C^w肵 printf()
               ĂяoȒPɌoƂł܂BA
               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肳Ă
          BƂ΁ÃR[h̏o͂ĂB

          complex sqrt (3.87267e-17, 0.632456)
          float sqrt (3.87267e-17, -0.632456)

             o ݊[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;
               }

             o 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;
               }

             o complex  sqrt ֐́Aatan2 gpĎ܂B
               ̗́Aatan2 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[ɂȂ܂BC++ 5.0 ł͂̂悤ȂƂ͂
          łB̃o[WŃG[ɂȂ̂͂Ȃł ?

          ̃eXgP[X́AC++ 5.0 RpCł́AG[ȂɃR
          pCу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 a.out

          KiɂƁÃeXgP[X͖łB _͈ȉ̐錾
          ɂ܂B

          friend ostream& operator<< (ostream&, const TList&);

          ̐錾́Ãev[gCX^XQƂĂ܂
          B

          C̎QƂ́Ath錾 1 ӏŔF\łƂ
          Aev[g錾ƈv܂Bth錾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[Bmy_int ɂ̓ANZXłȂ
                  int foo() {
                          return k; // G[Bk ɂ̓ANZXłȂ
                          }
                  };
          };

          ARM  C++ WɂƁAqɂȂNX́A܂
          NX̃o[ɓʂɃANZX邱Ƃ͂܂Bmy_int
           k  Outer ŔJȂ̂ŁAOuter ̃th
          o[ɃANZXł܂BqɂȂ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

             o ̃G[́AۃNX̃RXgN^܂̓fXgN
               ^AO֐Ɂuthisvp[^nƂɂ
               ܂B \zєj󎞂ɁAuthisv́ARXg
               N^܂̓fXgN^g̃NX̌^AŏIIɍ\
               zNX̌^͎܂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

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

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

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

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

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

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

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

          d`ꂽZbgɊNX֐܂߂ꍇ́AN
          X֐݂̃XR[vɓ邽߂ɎKv
          BftHg̕W[hŃRpCsĂꍇ́A
          ̎gpǉł܂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
                                                 
          };

     D. 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@\
          ێĂ܂BAftHgŎgpWCu
          Ƃ̃oCi݊͂܂B

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

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

          gnu  SGI  Web TCgł́ApubNł̕WCu
          zzĂ܂B܂ARogueWaveADinkumware Ȃǂ̃x_[
          烉Cuw邱Ƃł܂BSTL ɂẮA
          QƂĂB

       2. C++ W̃ev[gCu (STL) Kvł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 ƓI
          Cu 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у
          Cu悤ɂ܂Bp̃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@\
          ͒񋟂Ă܂BT[hp[eB̃Cu (LTLport Ȃ)
           -compat [hpɍ\łꍇ܂Ã[X
          ͂̂悤ȍ\T|[g܂B

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

          WCúA (C++ 5.0 ł) RpCɃo[
          ev[gѕ̓ꉻKvƂ@\T|[g
          ɍ\zꂽ̂łB̋@\ C++ 5.1 ȍ~Agp\
          AWCuɃIɂ邱Ƃ͂ł܂B
          ݊cĂ邩ł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`

               <deque>A<map>A<set>A<string>A<vector>  <
               iterator> ł́Ãev[g֐ (񃁃o[) ̓T|
               [g܂B

                  + mapAmultimapA setAmultisetAbasic_stringA
                    vectorAreverse_iteratorA istream_iterator
                    NX̏ꍇ:

                    bool operator!= ()

                  + mapAmultimapA setAmultisetAbasic_stringA
                    vectorA reverse_iterator NX̏ꍇ:

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

                  + mapAmultimapA setAmultisetAbasic_stringA
                    vector NX̏ꍇ:

                    void swap()

             o ɂꂽ@\: ftHg̃p[^gev
               [gNX̕ꉻ

          <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*> {}

       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> ɕϊ܂BARXgN^
          ߂Ɂ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.4A 5.5 ݂̂łB
          -library=rwtools7_std R}hgpẴCuƃ
          NĂB

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

     E. RpC̃ptH[}X̌

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

       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Ԃ͑啝ɒȂĂ܂BA̖
          ̂ł傤 ?

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

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

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

            c. ftHgł́AׂẴCX^XIuWFNg
               SunWS_cache TufBNgɏ܂܂Bʂ̃C
               X^Xꍇ́A|Wg̊Ǘɍő 95% ̃R
               pCԂ₳邱Ƃ܂Bev[g|W
               goCpXev[gCX^Xf (
               IAAÓIAєI) ̂ꂩgp\
               𒲂ׂĂB ̃fw肷ɂ́A
               -instances=model IvVgp܂B RpC
               ̖̌CX^Xɂꍇ́Aʂ̃CX^
               Xfgp邱ƂɂāA啝ɃRpCԂ
               Zk邱Ƃ܂B

               ̑փfł́AvO~OX^C񂳂
               邱ƂɒӂĂBev[gCX^Xf
               ɂĂ̏ڍׂ́AwC++ [U[YKChx́uev
               [g̃RpCvQƂĂB̃KCh́A
               http://docs.sun.com ICœł܂B

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

          -g IvVŃRpCsƁAo[W 5.0 Rp
          Cev[g̃fobOp̑ʂ̏o߁Ao
          CĩTCY傫Ȃ܂Bo[W 5.1 ł́A̎
          ނ̃vOɂāAfobÕTCY͑啝
          k܂B5.2A5.3A5.4  5.5 RpCł́A
          ptH[}XサĂ܂B̏ꍇAoCĩTCY
          ̏k 25%  50% ɂȂĂ܂Bǂ́AR
          [hŖOԂev[gǍpxNXK
          wgpĂꍇɓɌłB

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

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

          dmake (RpCɕtĂc[ 1 ) gpƁA
          ̃RpC𓯎Ɏsł܂BA̓Rp
          Cł́Aev[gLbVgpKv邽߁AL
          bVւ̃ANZX̋ptH[}X̃lbNɂȂ邱
          ܂B FAQ W 4c ŐĂIvVȂǁA
          LbV̖邽߂̃IvV𒲂ׂĂB
          ڍׂ́ARpCɕtwC++ [U[YKChx́ue
          v[g̃RpCvQƂĂB̃KCh́A
          http://docs.sun.com ICœł܂B

     F. 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͂̂ł傤
          ?


                      ---------------------------------
   * C++ ́AuinlinevL[[h̕t֐ɃCĈ
     傤 ? 邢́Â悤ɋLqƂĂACC
     Ȃ֐̂͂ǂĂł傤 ?

     {IɁARpĆA<inline> 錾w߂Ƃ݂ȂÂ悤ɐ
     ꂽ֐CC悤Ƃ܂Bo[W 5.1A5.2A
     5.3A5.4A 5.5 ̃RpCł́ACCASY
     ǂA葽̍\𗝉悤ɂȂĂ܂BA
     łA\𗝉łȂP[X݂܂BP[XɎ
     ܂B

        * 5.2A5.3A5.4A5.5 C++ RpCŊJnƁA܂Ɏs
          ֐ĂяoWJȂꍇ܂B̕ύX́AR
          pCxAo̓R[hTCYAюsx̋ύtƂ邽
          ߂ɖ𗧂܂B

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

        * ċ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܂BA-xO4 x
          ́AIveB}CUɂăCC邱Ƃ܂B

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

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

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

     C++ CC֐̃CCSɖɂɂ́A+d IvV
     gp܂B

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

   * stdlib Xg[́Agcc ܂ KAI Xg[ᑬłBpt
     H[}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ł邱Ƃ킩Ă܂BcOȂƂɁA]
          iostreams gpƂƂ́A stdlib ̋@\pł
          ȂA-library=iostreams gāAvOŜRpC
          Kv邱ƂӖ܂B܂A] iostreams g
          pɂ́Aꕔ\[XR[h̕ύXKvɂȂ邱Ƃ
          B

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

        * RogueWave  stdlib2.2.3 ̗pBcOȂƂɁÃCu
          ́Ao[W 5.0A5.1A 5.2 ̃RpCɃftHg
          ŕtĂ郉Cu stdlib2.1.1 ƌ݊܂B
          ̂߁AAvP[Vɑ̃~hEFAKvƂȂꍇ
          ɋ@\Ȃ\܂B

                                                XVt: 2003 N 3  1 
  ------------------------------------------------------------------------

Copyright xA?2003 Sun Microsystems, Inc., All rights reserved. Use is
subject to license terms.
