                                                : 2003 ǯ 3  1 

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

     ܼ

       A. С󡢥ѥåӥݡ

       B. ѥθߴ

       C. ǥ󥰤ӿ

       D. 饤֥θߴ

       E. ѥΥѥեޥ󥹤θ

       F. ¹ԻΥѥեޥ󥹤θ

     A. С󡢥ѥåӥݡ

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

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

       3. Sun Open Net Environment (ONE) Studio 8 ǻѤǤ饤֥
          Ȥơǧפ 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
               (A tutorial on the entire C++ standard library)

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

          ñϤ륽ɤϡɤϥȥ꡼
          ̤äƤޤñ˰ܹԤ뤿ˡʳΥإå
          <iostream.h><fstream.h> <strstream.h> ɸ
          ϥȥ꡼ƤޤΥإåϡ켰
          ϥȥ꡼ˤ륰Х͡ॹڡȹ
          åȤ󶡤ޤ

          ȤСΥɤϡ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()
          {
              // coutcin Ѥñ
              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;}

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

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

          C++ 4.04.1 4.2 ѥϾߴޤ
          (C++ 4.2 ޥ˥奢о줹륳ѥΥС֤ˡ̾
          沽꤬ޤ)

          ߴ⡼ (-compat) äƤ C++ 5.05.15.25.3
          5.4 5.5 ѥϡ4.2 ѥȾ̸ߴ
          ޤC++ 4.2 ȡС 5.05.15.25.35.4
           5.5 줿ºݤΥ֥ȥɤȤϴ˸ߴ
          ޤ³ѥ餬ȯǥХå () 
          ԥǥХåȸߴޤ

          ǥեɸ⡼ɤ C++ 5.05.15.25.35.4
          5.5 ѥϾߴޤºݤΥ֥ȥ
          ɤϴ˸ߴޤ³ѥȯǥХå
           () ԥǥХåȸߴޤ

       3. Sun Open Network Environment (ONE) Studio 8 ǻѤǤ饤
          ֥Ȥơǧפ RogueWave 饤֥򶵤Ƥ
          

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

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

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

          ʤΥѥå˴ؤǿˤĤƤϡȤɤ Hot News 
          Web ڡ˥ƤߤƤ
          ( http://sun.co.jp/software/sundev/suncc/hotnews.html) ˥
          ƤߤƤ

          ʤΥѥå 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           ƥ
                          ڥ졼ƥ󥰥ƥ

               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. ѥθߴ

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

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


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

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

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

             o 饹֥Ȥ֤ۤʤ롣

             o ؿθƤӽФۤʤ롣

             o ̾沽׽ۤʤ롣

             o 㳰ˡ̷⤹롣

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

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

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

       2. C++ ޤ C ץ F77F90F95 ץȤ߹
          ˤϡɤФ褤Ǥ礦 ?

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

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

     C. ǥ󥰤ӿ

       1. ɸ㳰饹ˤĤƤޤʥݡȤ󼨤ΤϤʤ
          Ǥ ?

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

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

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

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

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

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

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

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

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

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

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


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

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

          Solaris Ǥϡɸإå ˡɸ Unix ɬפ ¤
          exceptionѤޤusing ޤ using 
          Ѥ C++ ɸ㳰饹襹פȡͤ
          ȯޤ

          //  1

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

          //  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, 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
          };

          Υɤϡ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. ץ󥯤ȥƥץ졼ȥ󥹥󥹤
          ϤʤǤ ? 󥹥󥹤ϥƥץ졼ȥåˤ
          Ǥ


          ƥץ졼ȥåϡѥ餬륪֥ȥ
          ֤ΰ¸طꥹȤͭƥץ졼ȥ󥹥󥹤
          å˴ޤޤƤޤ֥ȥեưޤ
          ̾ѹ뤫֥ȥե饤֥˷礷
          硢åؤ³ޤ2 Ĥؼʤ򼡤˼
          ޤ

             o ֥ȥեľŪ˺ǽǥ쥯ȥ
               ƥץ졼ȥåƱǥ쥯ȥ֤
               

               ϻѤʤǤ

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

               ˼ѤƤ

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

               makefile ޥǥץ򥫥ץ벽Ǥޤ

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

               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 ѤƤȤޤ +w2 +d ѤƤʤȤ
          ˡؿŸʤȤٹåɽΤϤ
          Ǥ ?

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

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

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

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

          С 5.05.15.25.35.4 5.5 Ǥϡ-ptr 
          ץϥݡȤƤޤ󡣥С 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 ݥ
          󥿤Υåǽޤ󡣤˸¤ޤ󤬡
          褦ʤȤ󤲤ޤ

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

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

             o ǥХå񤷤ʤ롣ץޤ 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)

             o ߴ⡼ɤ 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;
               }

             o ɸ⡼ɤ 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;
               }

             o 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 a.out

          ʤˤȡΥƥȥ̵Ǥ ϰʲ
          ˤޤ

          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 ĤΤɤ餫ξ˵ޤ

             o Υ顼ϡݥ饹Υ󥹥ȥ饯ޤϥǥȥ饯
               顢ؿˡ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
               ƤӽФȤޤ

             o ŪʽһԤ鷺貾۴ؿƤӽ
               Ȥˤ⡢Υ顼뤳Ȥޤ
               Τ˽貾۴ؿꤹ뤳ȤϤǤޤƤӽФ
               Ͻ̾Ѥ۸ƤӽФᥫ˥Хѥ
               ΤߡƤӽФȤǤޤ

               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 
          Ǥ

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

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

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

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

     D. 饤֥θߴ

       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 ̵ˤ줿ǽ: ʬŪü첽Ƥؿƥץ졼
               Ȥΰ¿

               <deque><map><set><string><vector>  <
               iterator> ǤϡΥƥץ졼ȴؿ (С) ϥ
               Ȥޤ

                  + mapmultimap setmultisetbasic_string
                    vectorreverse_iterator istream_iterator
                    饹ξ:

                    bool operator!= ()

                  + mapmultimap setmultisetbasic_string
                    vector 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*> {}

       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.4 5.5 ΤߤǤ
          -library=rwtools7_std ޥɤѤƤΥ饤֥ȥ
          Ƥ

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

     E. ѥΥѥեޥ󥹤θ

       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.4 5.5 
          ˥ѥ֤ޤѥΥѥեޥ󥹤
          ­Ǥʤ硢ο侩αդƤ

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

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

            c. ǥեȤǤϡ٤ƤΥ󥹥󥹤֥Ȥ
               SunWS_cache ֥ǥ쥯ȥ˽񤭹ޤޤ̤Υ
               󥹤ϡݥȥδ˺ 95% Υ
               ѥ֤䤵뤳Ȥޤƥץ졼ȥݥ
               ȥХѥƥץ졼ȥ󥹥󥹲ǥ (
               Ū衢ŪȾŪ) Τ줫Ѳǽ
               Ĵ٤Ƥ Υǥꤹˤϡ
               -instances=model ץѤޤ ѥ
               θ󥹥󥹲ˤϡ̤Υ󥹥
               ǥѤ뤳Ȥˤäơ˥ѥ֤
               ṳ̂뤳Ȥޤ

               إǥǤϡץߥ󥰥뤬󤵤
               뤳ȤդƤƥץ졼ȥ󥹥󥹲
               ˤĤƤξܺ٤ϡC++ 桼ɡ٤Ρ֥ƥץ
               ȤΥѥפ򻲾ȤƤΥɤϡ
               http://docs.sun.com 饪饤Ǥޤ

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

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

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

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

          dmake (ѥ°Ƥġ 1 ) Ѥȡ
          ʣΥѥƱ˼¹ԤǤޤƱ
          Ǥϡƥץ졼ȥåѤɬפ뤿ᡢ
          åؤΥζ礬ѥեޥ󥹤Υͥåˤʤ뤳
          ޤ FAQ  4c Ƥ륪ץʤɡ
          å򤹤뤿ΥץĴ٤Ƥ
          ܺ٤ϡѥ°C++ 桼ɡ٤Ρ֥ƥ
          ץ졼ȤΥѥפ򻲾ȤƤΥɤϡ
          http://docs.sun.com 饪饤Ǥޤ

     F. ¹ԻΥѥեޥ󥹤θ

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

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


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

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

        * 5.25.35.45.5 C++ ѥǳϤȡޤ˼¹Ԥ
          ؿƤӽФŸʤ礬ޤѹϡ
          ѥ®١ϥɥӼ¹Ի®٤ζѹդȤ뤿
          Ωޤ

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

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

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

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

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

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

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

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

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

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

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

     C++ 5.4 ǤϡǥեȤΥȥ꡼饤֥Υѥեޥ󥹤
     夷Ƥޤ꤬ˤϡβ򻲹ͤˤƤ

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

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

        * RogueWave  stdlib2.2.3 ѡǰʤȤˡΥ饤֥
          ϡС 5.05.1 5.2 Υѥ˥ǥե
          °Ƥ饤֥ stdlib2.1.1 ȸߴޤ
          Τᡢץꥱ¾Υߥɥ륦ɬפȤʤ
          ˵ǽʤǽޤ

                                                : 2003 ǯ 3  1 
  ------------------------------------------------------------------------

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