                              A

   abstract                           ࠪ
      class                           ࠪ 
   abstract-declarator                ࠪ ⥫
   abstraction                        ࠪ
      data                            ࠪ 
      levels                          ஢ ࠪ樨
   access                             
      base class                         
      base class member                 童  
      class member                      童 
      control                         ஫ 㯠
      declaration                     ᠭ 㯠
      member name                        童
      protected member                  饭 童
      specifier                       ᯥ䨪 㯠
      virtual function                  㠫쭮 㭪樨
   Ada                                
   addition operator                   ᫮
   additive operators                 ⨢ 樨
   address                            
   address-of operator                  
   ADT abstract type                  ࠪ ⨯  ()
   aggregate                          ॣ
   Algol68                            68
   alignmemt                          ࠢ
   allocation                         ࠧ饭
   allocation-expression              ࠦ-ࠧ饭
   ambiguity                          筮
      resolution                      ࠧ襭 筮
   ambiguous type conversion          筮 ८ࠧ ⨯
   anachronism                        ஭
   anonymous union                    ﭭ ꥤ
   ANSI                               ANSI
   application framework              ઠ  ਫ
   argument                           ࠬ
   argument-declaration               ᠭ-ࠬ
   arithmetic                         䬥᪨
      conversion                      䬥᪮ ८ࠧ
      exception                       䬥᪠ ᮡ 
      fixed point                     䬥⨪ 䨪஢ 筮
      pointer                         䬥᪨ 樨  㪠⥫
      type                            䬥᪨ ⨯
      unsigned                        䬥⨪ 
   array                              ᨢ
      associative                     樠⨢ ᨢ
      initialization                  樠 ᨢ
      multidimensional                 ᨢ
      storage of                        ᨢ
      type                            ⨯ ᨢ
   arrow operator                     롮 童 
   ASCII character set                ⢮ ᨬ ASCII
   asm declaration                    ᠭ asm
   assembler                          ᥬ
   assignment                         ᢠ
      and initialization              ᢠ  樠
      and lvalue                      ᢠ  
   assignment-expression              ࠦ-ᢠ
   assignment-operator                -ᢠ
   associativity of operator          樠⨢ 権
   asynchronous events                ᨭ஭ ᮡ
   auto                               ⮬᪨
     destruction                      㭨⮦ ⮬᪨
     initialization                   樠 ⮬᪨
     specifier                        ᯥ䨪 auto
     storage class                      auto

                             B

   backslash                          ⭠ ஡ 
   backspace                          ᨬ 蠣 
   base                               
     class                             
     class access                        
     class cast                       ਢ   
   base-list                          ᯨ᮪-
   base-specifier                     ᯥ䨪-
   BCPL                               BCPL
   binding                            뢠
   bit                                ࠧ ()
     field                            ⮢ 
     pattern                          ᫥⥫쭮 ࠧ冷
     vector                           ࠧ來 
   bit-field                          ⮢ 
     address of                        ⮢ 
     alignment                        ࠢ ⮢ 
     declaration                      ᠭ ⮢ 
     layout                           ࠧ饭 ⮢ 
     type                             ⨯ ⮢ 
   bitwise                            ࠧ來
     AND operator                     ࠧ來 
     copy                             ࠧ來 ஢
     exclusive OR operator            ࠧ來 ᪫饥 
     inclusive OR operator            ࠧ來 饥 
     logical operators                ᪨ 樨
     operators                        ࠧ來 樨
   block                              
     statement { }                    ⠢ 
     structure                         
   body, function                     ⥫ 㭪樨
   break statement                     break
   buffering, I/O                     ਧ -뢮
   built-in                           ஥
     operator                         ஥ 
     type                             ஥ (᭮) ⨯

                           C

   C                                  C
   C ANSI                             C ANSI
     C++                              C  C++
   C++                                C++
      evolution                       ࠧ⨥ C++
   call                               맮
      by reference                    맮  뫪
      by value                        맮  祭
      function                        맮 㭪樨
      operator function               맮 ୮ 㭪樨
   callback                            맮
   carriage return                     ⪨
   cast                               ਢ
      base class                      ਢ   
      class object                    ਢ  ꥪ 
      derived class                   ਢ  ந 
      integer to pointer              ਢ 楫  㪠⥫
      operator                         ਢ
      pointer to function             ਢ 㪠⥫  㭪樨
      pointer to integer              ਢ 㪠⥫  楫
      pointer to member               ਢ 㪠⥫  童
      pointer to pointer              ਢ  㪠⥫
                                       㣮
      reference                       ਢ 뫪
   cast-expression                    ࠦ-ਢ
   catch                              墠
   CDT concrete type                   ⨯  ()
   char type                          ⨯ char
      type, signed                    ⨯ signed char
      type specifier                  ᯥ䨪-⨯-char
      type, unsigned                  ⨯ unsigned char
   character                          ᨬ
      constant                        ᨬ쭠 ⠭
      set, ASCII                      ⢮ ᨬ ASCII
      set, EBCDIC                     ⢮ ᨬ EBCDIC
   class                              
      abstract                        ࠪ 
      alignment                       ࠢ 
      and type                          ⨯
      base                             
      constructor and abstract          ࠪ 
      constructor for derived           ந 
      conversion                      ८ࠧ ꥪ 
      conversion ambiguity            筮 ८ࠧ
                                      ꥪ 
      declaration                     ᠭ 
      declaration, forward            ।⥫쭮 ᠭ 
      declaration, friend             ᠭ 㦥⢥ 
      definition                      । 
      derived                         ந 
      destructor for derived           ந 
      exception                        ᮡ 樨
      friend                          㦥⢥ 
      handle                          ࠢ騩 
      hierarchy                        ᮢ
      interface                       䥩 
      member                          童 
      member access                     童 
      member access operator           롮 童 
      member, alignment               ࠢ 童 
      member, constructor for          童 
      member declaration              ᠭ 童 
      member function                 㭪-童 
      member initialization           樠 童 
      member of derived               童 ந 
      member, private                  童 
      member, public                  騩 童 
      member, static                  ᪨ 童 
      name                             
      name declaration                ᠭ  
      name, elaborated                ᫮  
      nested                           
      node                            㧫 
      pointer to                      㪠⥫  
      private base                      
      scope                             
      storage                           
      template                        蠡 
      versus struct                     
      versus union                      ꥤ
      virtual base                    㠫  
   class-key                          㦥 ᫮ class
   class-name                         -
   class-specifier                    ᯥ䨪-
   CLU                                CLU
   Cobol                              
   comma operator                      
   command line argument              ࠬ  ப
   comment                            ਩
   compatibility                      ᮢ⨬
       with ANSI C summary            ᮢ⨬  ANSI C (᢮)
       with C summary                 ᮢ⨬   (᢮)
   compilation, separate              ࠧ쭠 ࠭
   complete-class-name                --
   compound statement                 ⠢ 
   concatenation string               ⥭ ப
   concrete type                       ⨯
       type, CDT                       ⨯  ()
   conditional                        ᫮
       compilation                    ᫮ ࠭
       expression operator             ᫮ ( ? : )
   constant                           ⠭
       character                      ᨬ쭠 ⠭
       decimal                        筠 ⠭
       double                         ⠭ double
       enumeration                    ⠭ ᫥
       expression                     ࠦ ⠭
       float                          ⠭ float
       floating point                 ⠭  饩 窮
       hexadecimal                    ⭠筠 ⠭
       integer                        楫 ⠭
       long                           ⠭ long
       long double                    ⠭ long double
       multicharacter                 ᨬ쭠 ⠭
       octal                          쬥筠 ⠭
       of user-defined type           ⠭ 짮⥫᪮ ⨯
       unsigned                       ⠭ unsigned
   constant-expression                ࠦ-⠭
   constructor                        
       address of                      
       call, explicit                  맮 
       conversion by                  ८ࠧ  
                                      
       copy                            ஢
       default                        ⠭ 
       default copy                   ⠭  ஢
       definition                     । 
       exception handling               ࠡ⪥
                                      ᮡ 権
       for array members               童 ᨢ
       for class member                童 
       for derived class               ந 
       for free store variable         ६,
                                      ࠧ頥  ᢮ 
       for global variable             쭮 ६
       for local variable              쭮 ६
       for temporary                   ६ ꥪ
       inheritance                    ᫥ ஢
       local object                    쭮 ꥪ
       type of                        ⨯ 
       undefined argument to          । ࠬ 
       union                           ꥤ
       virtual                        㠫 
   containment                        ਭ
       and inheritance                ਭ  ᫥
   continue statement                  continue
   control access                     ஫ 㯠
   conversion                         ८ࠧ (⨯)
       argument                       ८ࠧ ࠬ
       arithmetic                     䬥᪨ ८ࠧ
       array pointer                  ८ࠧ 㪠⥫  ᨢ
       base class pointer             ८ࠧ 㪠⥫
                                       
       by assignment                  ८ࠧ  ᢠ
       by constructor                 ८ࠧ ஬
       class                          ८ࠧ  (⨯)
       derived class pointer          ८ࠧ 㪠⥫
                                       ந 
       floating point integer         ८ࠧ 祭 
                                      饩 窮  楫
       implicit                        ८ࠧ
       implicit type                   ८ࠧ ⨯
       integer                        ८ࠧ 楫
       integer to pointer             ८ࠧ 楫  㪠⥫
       lvalue                         ८ࠧ 
       null pointer                   ८ࠧ ⮣ 㪠⥫
       of pointer to class            ८ࠧ 㪠⥫  
       operator                        ८ࠧ
       pointer                        ८ࠧ 㪠⥫
       pointer to function            ८ࠧ 㪠⥫  㭪
       pointer to integer             ८ࠧ 㪠⥫  楫
       pointer to member              ८ࠧ 㪠⥫  童
       pointer to pointer             ८ࠧ  㪠⥫
                                       㣮
       reference                      ८ࠧ 뫪
       return type                    ८ࠧ ⨯ 頥
                                      祭
       rules, type                    ࠢ ८ࠧ ⨯
       standard                       ⠭⭮ ८ࠧ
       user-defined                   짮⥫᪮ ८ࠧ
       user-defined type              ८ࠧ 짮⥫᪮ ⨯
       void* pointer                  ८ࠧ 㪠⥫ ⨯ void*
       zero pointer                   ८ࠧ 㫥 㪠⥫
   conversion-function-name           -㭪樨-८ࠧ
   copy                               ஢
       bitwise                        ࠧ來 ஢
       deep                           㡮 ஢
       shallow                        孮⭮ ஢

                                 D

   data                               
       abstraction                    ࠪ 
       abstraction, support for       প ࠪ樨 
       abstraction vs inheritance     ࠪ   ᫥
       global                          
   debugging                          ⫠
   declaration                        ᠭ
       access                         ᠭ 㯠
       argument                       ᠭ ࠬ
       array                          ᠭ ᨢ
       as definition                  ᠭ  ⢥ ।
       asm                            ᠭ asm
       bit-field                      ᠭ ⮢ 
       class                          ᠭ 
       class member                   ᠭ 童 
       class name                     ᠭ  
       constant pointer               ᠭ ﭭ 㪠⥫
       default argument               ᠭ ⠭⭮ ࠬ
       definition versus              ᠭ  ।
       ellipsis in function           ᠭ   㭪樨
       extern                         ᠭ extern
       forward                        ।⥫쭮 ᠭ
       friend                         ᠭ friend
       friend class                   ᠭ 㦥⢥ 
       function                       ᠭ 㭪樨
       function member                ᠭ 㭪樨-童
       function template              ᠭ 蠡 㭪樨
       local class                    ᠭ 쭮 
       member                         ᠭ 童
       name                           ᠭ 
       pointer                        ᠭ 㪠⥫
       reference                      ᠭ 뫪
       register                       ᠭ register
       specifier                      ᯥ䨪 ᠭ
       statement                       ᠭ
       static member                  ᠭ ᪮ 童
       storage class                  ᠭ  
       syntax summary                 ᨭ⠪ ᠭ (᢮)
       syntax summary, class          ᨭ⠪ ᠭ  (᢮)
       template                       ᠭ 蠡 ⨯
       template class                 ᠭ 蠡 
       template function              ᠭ 蠡 㭪樨
       type                           ᠭ ⨯
       typedef                        ᠭ typedef
   declaration                        ᠭ
   declaration-list                   ᯨ᮪-ᠭ
   declaration-statement              -ᠭ
   declarator                         ⥫
   declarator-list                    ᯨ᮪-⥫
   decl-specifier                     ᯥ䨪-⥫
   decrement operator                  ६
   default access control             ⠭ ஫ 㯠
        argument                      ⠭  ࠬ
        argument evaluation           ᫥ ⠭⭮ ࠬ
        argument, scope                 ⠭⭮ ࠬ
        argument type checking        ஢ઠ ⨯ ⠭⭮ ࠬ
        array size                    ࠧ ᨢ  㬮砭
        assignment operator           ⠭⭠  ᢠ
        constructor                   ⠭ 
        copy constructor              ⠭  ஢
        destructor                    ⠭ 
        initialization                ⠭⭠ 樠
   definition                         ।
        class                         । 
        constructor                   । 
        enumerator                    ।  ᫥
        function                      । 㭪樨
        function template             । 蠡 㭪樨
        inline member function        । 㭪樨-童 inline
        member                        । 童
        member function               । 㭪樨-童
        object                        । ꥪ
        pure virtual function         ।  㠫쭮
                                      㭪樨
        scope of function             ।  
                                      㭪樨
        static member                 । ᪮ 童
        template class                । 蠡 
        template function             । 蠡 㭪樨
        virtual function              । 㠫쭮 㭪樨
   delete operator                     delete
   dereferencing                      ᢥ (ᢥ 饭)
   derived class                      ந 
   design aims                        楫 ஥஢
        and classes                   ஥஢  
        and language                  ஥஢  
        and programming               ஥஢  ணࠬ஢
        library                       ஥஢ ⥪
        method                        ⮤ ஥஢
        of C++                        ஥஢ ++
        stage                         ⠤ ஥஢
        steps                         蠣 ஥஢
        tools                         ।⢠ ஥஢
   destruction                        㭨⮦
        of auto                       㭨⮦ ⮬᪨
        of local static               㭨⮦  ᪨
        of local variable             㭨⮦ 쭮 ६
   destructor                         
        default                       ⠭ 
        for derived class              ந 
        for temporary                  ६ ꥪ
        inheritance                   ᫥ 
        invocation                    맮 
        local object                   쭮 ꥪ
        virtual                       㠫 
   development cycle                  横 ࠧ
        process                        ࠧ
        stages                        ⠤ ࠧ
   difference from C expression       ⫨  ᫥ ࠦ  
   evaluation
       from C function declaration    ⫨  ᠭ 㭪樨  
       from C linkage                 ⫨  뢠  
       from C name space              ⫨  ࠭⢠  
       from C scope                   ⫨    
   direct base class                  אַ  
   directed acyclic graph             ࠢ 横 
   directive error preprocessing      ப error
       pragma preprocessing           ப pragma
       preprocessing                  ப ९
   discriminating union               ஫㥬 ꥤ
   discrimination of exceptions       ࠧ ᮡ 権
   do statement                        do
   double constant                    ⠭ double
       type                           ⨯ double
       type specifier                 ᯥ䨪 ⨯ double
   dynamic type checking              ᪨ ஫ ⨯

                              E

   EBCDIC character set               ⢮ ᨬ EBCDIC
   elaborated class name              ᫮  
   ellipsis ...                        ...
   empty argument list                ⮩ ᯨ᮪ ࠬ஢
       queue                           ।
       statement                      ⮩ 
   encapsulation                      
   enum type specifier                ᯥ䨪 ⨯ enum
   enumeration                        ᫥
       constant                       ⠭ ᫥
   enumerator                          ᫥
   equality operator                   ࠢ⢠
   equivalence template type          ⭮ 蠡 ⨯
       type                           ⭮ ⨯
   error handling                     ࠡ⪠ 訡
       handling, multilevel           ஢ ࠡ⪠ 訡
       linkage                        訡 뢠
       preprocessing directive        ப error
       run-time                       ᪠ 訡
   escape character                   ࠢ騩 ᨬ (\)
       sequence                       ࠢ ᫥⥫쭮
   evaluation default argument        ᫥ ⠭⭮ ࠬ
       of expression, order of        冷 ᫥ ࠦ
       order of                       冷 ᫥
       order of argument              冷 ᫥ ࠬ஢
   evolution of ++                   ࠧ⨥ ++
   exception                          ᮡ 
       arithmetic                     䬥᪠ ᮡ 
       class                           ᮡ 樨
       handler                        ࠡ稪 ᮡ 樨
       hierarchies                     ᮡ 権
       throwing                        ᮡ 樨
   exception-declaration              ᠭ-ᮡ-樨
   exception-specification            ᯥ䨪-ᮡ-樨
   exhaustion free store              ௠ ᢮ 
   explicit constructor call           맮 
       destructor call                 맮 
       type conversion                 ८ࠧ ⨯
   expression                         ࠦ
       assignment                     ࠦ ᢠ
       constant                       ﭭ ࠦ
       order of evaluation of         冷 ᫥ ࠦ
       postfix                        䨪᭮ ࠦ
       primary                        ࢨ筮 ࠦ
       reference                      뫮筮 ࠦ
       statement                       ࠦ
       syntax summary                 ᢮ ᨭ⠪ ࠦ
       unary                          㭠୮ ࠦ
   expression-list                    ᯨ᮪-ࠦ
   expression-statement               -ࠦ
   extern declaration                 ᠭ 譨
       linkage                        뢠 譨
       linkage specification          ᯥ䨪 譥 뢠
   external linkage                   譥 뢠

                               F

   fat interface                        䥩
   field                               
      bit                              ⮢ 
   fixed point arithmetic              䬥⨪  䨪஢ 筮
   float constant                      ⠭ float
      type                             ⨯ float
      type specifier                   ᯥ䨪 ⨯ float
   for statement                        for
   format string                       ப ଠ
   form feed \f                        ॢ ଠ \f
   forward class declaration           ।⥫쭮 ᠭ 
      declaration                      ।⥫쭮 ᠭ
      declaration of template          ।⥫쭮 ᠭ 蠡 ⨯
   free store                          ᢮ 
      store exhaustion                 ௠ ᢮ 
      store management                 ࠢ ᢮ 
   friend                              friend
      class                            㦥⢥ 
      declaration                      ᠭ friend
      function                         㦥⢥ 㭪
      member function                  㭪-童 friend
      scope of                           friend
      specifier                        ᯥ䨪 friend
   function                            㭪
      argument                         ࠬ 㭪樨
      argument passing                 । ࠬ 㭪樨
      argument type checking           ஫ ⨯ ࠬ஢ 㭪樨
      argument type conversion         ८ࠧ ⨯ ࠬ
                                       㭪樨
      body                             ⥫ 㭪樨
      call                             맮 㭪樨
      call mechanism                   堭 맮 㭪樨
      call, recursive                  ४ᨢ 맮 㭪樨
      declaration                      ᠭ 㭪樨
      definition                       । 㭪樨
      friend                           㦥⢥ 㭪
      inline                           㭪-⠭
      inline member                    㭪-童 inline (⠭)
      linkage specification            ᯥ䨪 裡 㭪樨
      member                           㭪-童
      object                           ꥪ-㭪
      operator                         ୠ 㭪 (operator)
      pointer to                       㪠⥫  㭪
      pointer to member                㪠⥫  㭪-童
      pure virtual                      㠫쭠 㭪
      scope                              㭪樨
      specifier                        ᯥ䨪 㭪樨
      template                         蠡 㭪
      type                             ⨯ 㭪樨
      value return                     頥 㭪樥 祭
      virtual                          㠫쭠 㭪
   function-definition                 ।-㭪樨
   fundamental type                    ᭮ ⨯

                               G

   garbage collection                  ᡮઠ 
   global anonymous union              쭮 ﭭ ꥤ
      data                              
      name                             쭮 
      objects                           ꥪ
      scope                            쭠  
   goto statement                       goto
   greater than operator                 祬
   greater than or equal operator         ࠢ
   grouping of exceptions              㯯஢ ᮡ 権

                              H
   handle class                        ࠢ騩 
   handler, exception                  ࠡ稪 ᮡ 樨
   handler-list                        ᯨ᮪-ࠡ稪
   header file                          䠩
   hexadecimal constant                ⭠筠 ⠭
   hierarchy class                      ᮢ
      object                            ꥪ⮢
   horizontal tab \t                   ਧ⠫쭠 ⠡ \t
   hybrid design                       ਤ ஥

                              I

   identifier                          䨪
   if statement                         if
   implementation                      ॠ
   implicit conversion                  ८ࠧ
      destructor call                   맮 
      type conversion                   ८ࠧ ⨯
      user-defined conversion           짮⥫᪮
                                       ८ࠧ
   include directory, standard         ⠭ ⠫ include
      file                             砥 䠩
   inclusion source file               祭 室 䠩
   increment operator                   ६
   indentation                         뤥 ஡
   inderect base class                 ᢥ  
   inderection operator                 ᢥ
   inequality operator                  ࠢ
   inheritance                         ᫥
      containment and                  ਭ  ᫥
      multiple                         ⢥ ᫥
      of constructor                   ᫥ 
      of destructor                    ᫥ 
   initialization                      樠
      array                            樠 ᨢ
      array of class objects           樠 ᨢ ꥪ⮢ 
      assignment and                   樠  ᢠ
      character array                  樠 ᨢ ᨬ
      class member                     樠 童 
      class object                     樠 ꥪ 
      default                          ⠭⭠ 樠
      dynamic                          ᪠ 樠
      member                           樠 童
      member object                    樠 ꥪ-童
      of base class                    樠  
      of structure                     樠 
   initializer                         樠
   initializer-list                    ᯨ᮪-樠஢
   inline                              inline
      function                         㭪-⠭
      member function                  㭪-童 inline
   input and output                    -뢮
      of built-in type                  ஥ ⨯
      of user-defined type              짮⥫᪨ ⨯
      operator >>                        >>
   int                                 int
     type                              ⨯ int
     type specifier                    ᯥ䨪 ⨯ int
   integer constant                    楫 ⠭
     conversion                        楫᫥ ८ࠧ
   integral promotion                  ⠭⭮ 楫᫥
                                       ८ࠧ
     type                              楫᫥ ⨯
   interface                           䥩
     class                             䥩 
     inheritance                       ᫥ 䥩
     fat                                䥩
     specifications                    ᯥ䨪樨 䥩
   internal linkage                    ७ 뢠
     structure                         ७ 
   I/O buffering                       ਧ -뢮
   iteration                           
     statement                          樨

                            J

   jump statement                        室
   jump-statement                       -室

                            K

   keyword                              㦥 ᫮
      list                              ᯨ᮪ 㦥 ᫮

                            L

   label                                 ⪠
      case                               ⪠ case
      default                            ⪠ default
      scope of                             ⪨
   labeled statement                     祭 
   language                              
      design and                         ஥஢  
      high-level                          ᮪ ஢
      low-level                            ஢
   layout bit-field                      ᯮ ⮢ 
      class objects                      ᯮ ꥪ⮢ 
   left shift operator                    ᤢ 
   less than operator                      祬
      than or equal to operator             ࠢ
   levels of abstraction                 ஢ ࠪ樨
   lexical conventions                   ᪨ ᮣ襭
   library                               ⥪
      design                             ஥஢ ⥪
      headers                            ⥪  䠩
      initialization                     樠 ⥪
   lifetime of object                    ६  ꥪ
   linkage                               뢠
      consistency                        ᮣᮢ 뢠
      error                              訡 뢠
      external                           譥 뢠
      internal                           ७ 뢠
   linker-specification                  ᯥ䨪-裡
   linker                                । 痢
   Lisp                                  
   list of operator functions            ᯨ᮪  㭪権
   literal                               ࠫ
      constants                          ࠫ ⠭
   loader                                稪
   local class declaration               ᠭ 쭮 
      class member function              㭪-童 쭮 
      class, scope of                      쭮 
      scope                              쭠  
   locking                               ஢ ()
   logical AND operator                   ᪮ 
      OR operator                         ᪮ 
      negation operator                   ᪮ 栭
      operators, bitwise                 ࠧ來 ᪨ 樨
   long                                  long
      constant                           ⠭ long
      double                             long double
      double constant                    ⠭ long double
      double type                        ⨯ long double
      type                               ⨯ long
   loop statement                         横
   lvalue                                
      assignment and                       ᢠ
      cast                               ਢ 
      conversion                         ८ࠧ 
      modifiable                         塞 

                              M

   macro                                 ப
      definition, preprocessing          ம।
      expansion, preprocessing           ய⠭
      function-like                      㭪樮쭠 ப
      name, scope of                       ம।
      names, predefined                  ।। ந
      preprocessing                      மࠡ⪠
      syntax summary                     ᨭ⠪ ம। (᢮)
   maintenance, software                 ᮯ஢ ணࠬ
   management                            ࠢ
      free store                         ࠢ ᢮ 
      memory                             ࠢ 
   manipulator                           
   member                                童
   member-declaration                    ᠭ-童
   member-declarator                     ⥫-童
   member-list                           ᯨ᮪-童
   modifiable lvalue                     塞 
   modular programming                   쭮 ணࠬ஢
   modularity                            쭮
   multicharacter constant               ᨬ쭠 ⠭
   multidimensional array                 ᨢ
   multiple inheritance                  ⢥ ᫥
   multiplication operator                㬭
   multiplicative-expression             ⨯⨢-ࠦ

                                 N

   name                                  
      global                             쭮 
      hiding                             뢠 
      length of                           
      linkage of local                   뢠 쭮 
      overloaded function                 ॣ㦥 㭪樨
      overloaded member                   ॣ㦥 童
      qualified                          筥 
      scope of                             
   nested class declaration              ᠭ  
      class, scope of                       
   new operator                           new
   newline \n                             ப \n
   node class                            㧫 
   null character                        ᨬ null '\0'
      pointer                            ⮩ 㪠⥫ (null)

                                O

   object                                ꥪ
   object-oriented programming           ꥪ⭮-ਥ஢
                                         ணࠬ஢
   octal constant                        쬥筠 ⠭
      number                             쬥筮 ᫮
   operand const                         ࠭ const
      reference                          ࠭ 뫪
      volatile                           ࠭ volatile
   operator ,                             ,
      !                                   !
      #                                   #
      ##                                  ##
      %=                                  %=
      &&                                  &&
      &=                                  &=
      *=                                  *=
      *=, user-defined                   짮⥫᪠  *=
      +, user-defined                    짮⥫᪠  +
      ++                                  ++
      ++, user-defined                   짮⥫᪠  ++
      +=                                  +=
      -, user-defined                    짮⥫᪠  -
      --                                  --
      --, user-defined                   짮⥫᪠  --
      -=                                  -=
      ->, user-defined                   짮⥫᪠  ->
      /=                                  /=
      ::                                  ::
      <<, output                          뢮 <<
      <<=                                 <<=
      =, user-defined                    짮⥫᪠  =
      >>, input                            >>
      >>=                                 >>=
      ^=                                  ^=
      address-of                           
      assignment                          ᢠ
      associativity                      樠⨢ 権
      binding strength                   冷 믮 権
      built-in                           ஥ 樨
      function call                       맮 㭪樨
      precedence                         ਮ 権
      sizeof                              sizeof
      subscripting                        樨
      summary                            ᢮ 権
      user-defined                       짮⥫᪠ 
   operator function                     ୠ 㭪
      function, list of                  ᯨ᮪  㭪権
   order of argument evaluation          冷 ᫥ ࠬ஢
      of evaluation                      冷 ᫥
   output formatted                      ଠ஢ 뢮
      input and                            뢮
      of built-in type                   뢮 ஥ ⨯
      of user-defined type               뢮 짮⥫᪨ ⨯
      operator <<                         뢮 <<
   overflow                              ९
   overloaded assignment operator        ॣ㧪 樨 ᢠ
      binary operator                    ॣ㧪 ୮ 樨
      decrement operator                 ॣ㧪 ६
      function call operator             ॣ㧪 樨 맮
      function name                      ॣ㧪  㭪樨
      increment operator                 ॣ㧪 ६
      member access operator             ॣ㧪 樨 롮 童
      member name                        ॣ㧪  童
      operator                           ॣ㧪 樨
      subscripting operator              ॣ㧪 樨
      unary operator                     ॣ㧪 㭠୮ 樨
   overloading                           ॣ㧪
      and access                         ॣ㧪  
      and scope                          ॣ㧪   
      resolution                         ࠧ襭 ॣ㧪
      resolution rules                   ࠢ ࠧ襭 ॣ㧪
   overriding virtual function           ८। 㠫쭮
                                         㭪樨

                                  P

   paradigm, programming                 ࠤ ணࠬ஢
   placement                             㪠 ࠧ饭
   pointer                               㪠⥫
      arithmetic                         䬥᪨ 樨 㪠⥫
      assignment to                      ᢠ 㪠⥫
      comparison                         ࠢ 㪠⥫
      const                              㪠⥫ const
      conversion                         ८ࠧ 㪠⥫
      declaration                        ᠭ 㪠⥫
      null                               ⮩ 㪠⥫ null
      size of                            ࠧ 㪠⥫
      substraction                       ⠭ 㪠⥫
      type                               ⨯ 㪠⥫
   postfix ++ and --                     䨪 ++  --
      expression                         䨪᭮ ࠦ
   precedence of operator                ਮ 権
   predefined address-of operator        ।। 
                                          
      assignment operator                ।। ᢠ
      macronames                         ।। ந
   prefix ++ and --                      䨪 ++  --
   preprocessing                         மࠡ⪠
      directive                          ப
      directive, error                   ப error
      directive, null                    ப null
      directive, pragma                  ப pragma
      macro definition                   ம।
      macro expansion                    ய⠭ (⠭)
      syntax summary                     ᢮ ப
   primary expression                    ࢨ筮 ࠦ
   private                               private
      base class                           
      class member                        童 
   procedural programming                楤୮ ணࠬ஢
   program                               ணࠬ
      environment                        㦥 ணࠬ
      partitioning                       ࠧ ணࠬ
      start                               ணࠬ
      termination                        襭 ணࠬ
   protected                             protected
      member                             饭 童
      member access                        饭 童
   prototypes                            ⨯
   public                                public
      class member                       騩 童 
   pure specifier                        ᯥ䨪 pure
      virtual function                    㠫쭠 㭪
   pure-specifier                        ᯥ䨪-pure

                            Q

   qualified name                        筥 
   qualified-class-name                  筥--
   qualified-name                        筥-
   qualified-type-name                   筥--⨯
   queue empty                            ।
   quote, single                         筠 窠
      double                              窠

                             R

   range checking                        ஫ 
   recursion                             ४
   recursive decent parser                ४ᨢ ᪠
      function call                      ४ᨢ 맮 㭪樨
   reference                             뫪
      assignment                         ᢠ 뫪
      assignment to                      ᢠ 뫪
      call by                            맮  뫪
      cast                               ਢ 뫪
      conversion                         ८ࠧ 뫪
      const                              뫪 const
      declaration                        ᠭ 뫪
      initialization                     樠樨 뫪
      operand                            ࠭ 뫪
      overloading and                    ॣ㧪  뫪
      volatile                           뫪 volatile
   register declaration                  ᠭ register
      initialization                     樠 ॣ
   relational operator                    ⭮襭
   relational-expression                 ࠦ-⭮襭
   reserved identifier                   १ࢨ஢ 䨪
   resolution ambiguity                  ࠧ襭 筮
      scoping ambiguity                  ࠧ襭 筮
                                          
      template function overloading      ࠧ襭 ॣ㧪 蠡
                                         㭪樨
   resource acquisition                   
      exhaustion                         ௠ 
      release                            ᢮ 
   re-throw                                (ᮡ 樨)
   return                                return
   return statement                       return
   return type                           ⨯ 頥 祭
   run-time error                        ᪠ 訡
      initialization                     ᪠ 樠
      type information                   ᪠ ଠ  ⨯

                                 S

   scope                                  
      class                                
      file                               䠩  
      function                             㭪樨
      global                             쭠  
      local                              쭠  
      of label                             ⪨
      of local class                       쭮 
      of macro name                        ந
      of name                              
      of nested class                       
      resolution operator                 ࠧ襭 
                                         
      rules summary                      ᢮ ࠢ  
   separate compilation                  ࠧ쭠 ࠭
   shift-expression                      ࠦ-ᤢ
   short type                            ⨯ short
      type specifier                     ᯥ䨪 ⨯ short
   side effects                           䥪
   sign extension                        ࠧ 
   signed char type                      ⨯ signed char
      type                                ⨯
   simple-type-name                      -⮣-⨯
   Simula                                㫠
   size of pointer                       ࠧ 㪠⥫
      of string                          ࠧ ப
      of structure                       ࠧ 
   sizeof operator                        sizeof
   Smalltalk                             Smalltalk
   source file                           室 䠩
      file, inclusion                    祭 室 䠩
   special character                     ᯥ樠 ᨬ
   specifier auto                        ᯥ䨪 auto
      declaration                        ᯥ䨪 ᠭ
      friend                             ᯥ䨪 friend
      function                           ᯥ䨪 㭪樨
      inline                             ᯥ䨪 inline
      static                             ᯥ䨪 static
      storage class                      ᯥ䨪  
      template                           ᯥ䨪 蠡 ⨯
      typedef                            ᯥ䨪 typedef
      virtual                            ᯥ䨪 virtual
   stack unwinding                       稢 ⥪
   standard component                    ⠭ 
      conversion                         ⠭⭮ ८ࠧ
      headers                            ⠭  䠩
      include directory                  ⠭ ⠫ 砥
                                         䠩
      libraries                          ⠭ ⥪
   statement                             
      break                               break
      compound                           ⠢ 
      continue                            continue
      declaration                         ᠭ
      do                                  do
      empty                              ⮩ 
      expression                          ࠦ
      for                                 for
      goto                                goto
      if                                  if
      summary                            ᢮ ஢
      switch                              switch (४⥫)
      syntax summary                     ᨭ⠪ ஢
      while                               while
   static type checking                  ᪨ ஫ ⨯
   static                                static
      class member                       ᪨ 童 
      linkage of                         뢠 ᪨
      local object                       ᪨  ꥪ
      member                             ᪨ 童
      member declaration                 ᠭ ᪮ 童
      member definition                  । ᪮ 童
      member function                    ᪠ 㭪-童
      specifier                          ᯥ䨪 static
      storage class                      ᪨  
   stream closing of                     ⨥ ⮪
      file and                           䠩  ⮪
      state                              ﭨ ⮪
      string                             ப ⮪
   string class                          ப 
      concatenation                      ⥭ ப
      constant                           ⠭ ப
      type of                            ⨯ ப
      wide-character                     பᨬ쭠 ப
   struct                                struct
      type specifier                     ᯥ䨪 ⨯ struct
   structure                             
      initialization of                  樠 
   subclass                               
   subscripting user-defined             짮⥫᪠  樨
   summary class declaration syntax      ᨭ⠪ ᠭ 
      compatibility with ANSI C          ᮢ⨬  ANSI C
      compatibility with C               ᮢ⨬  
      declaration syntax                 ᨭ⠪ ᠭ
      declarator syntax                  ᨭ⠪ ⥫
      exception handling syntax          ᨭ⠪ ᮡ 権
      expression syntax                  ᨭ⠪ ࠦ
      macro syntax                       ᨭ⠪ ப
      scope rules                        ࠢ ⥩ 
      statement syntax                   ᨭ⠪ ஢
      template syntax                    ᨭ⠪ 蠡 ⨯
   support for data abstraction          প ࠪ樨 
   for object-oriented programming       প ꥪ⭮-ਥ஢
                                         ணࠬ஢

                                   T

   template                              蠡 ⨯
      class                              蠡 
      class declaration                  ᠭ 蠡 
      class definition                   । 蠡 
      declaration                        ᠭ 蠡 ⨯
      function                           蠡 㭪
      function declaration               ᠭ 蠡 㭪樨
      function definition                । 蠡 㭪樨
      linkage of                         뢠 蠡 ⨯
      member function                    蠡 㭪-童
      specifier                          ᯥ䨪 template
      syntax summary                     ᨭ⠪ 蠡 ⨯
   template-arg                          ࠬ-蠡-⨯
   template-arg-list                     ᯨ᮪-ࠬ-蠡-⨯
   template-argument                     ࠬ-蠡-⨯
   template-argument-list                ᯨ᮪-ࠬ஢-蠡-⨯
   template-class-name                   -蠡-
   template-declaration                  ᠭ-蠡-⨯
   temporary                             ६ ꥪ
   this                                  this
   throw                                 throw
   throw-expression                      ࠦ-᪠
   throwing, exception                    ᮡ 樨
   throw-point                           窠 ᪠
   token                                 ᥬ
   tools design                          ஥஢ ࢨ ணࠬ
   translation phases                    ⠤ ࠭樨
      unit                                ࠭樨
   trigraph                              ਣ
   try                                   try
   try-block                             ஢塞-
   type                                  ⨯
      user-defined                       짮⥫᪨ ⨯
   type-specifier                        ᯥ䨪-⨯

                               U

   unary expression                      㭠୮ ࠦ
       minus operator                     㭠 
       operator                          㭠ୠ 
       operator, user-defined            짮⥫᪠ 㭠ୠ 
       plus, operator                     㭠 
   unary-expression                      㭠୮-ࠦ
   unary-operator                        㭠ୠ-
   uncaught exception                    墠祭 ᮡ 
   undeclared argument                   ᠭ ࠬ
   underscore character                  ᨬ ન _
   unexpected exceptions                  ᮡ 樨
   union                                 ꥤ
      anonymous                          ﭭ ꥤ
      constructor                         ꥤ
      destructor                          ꥤ
      discriminating                     ஫㥬 ꥤ
      initialization                     樠 ꥤ
      member function                    㭪-童 ꥤ
      type specifier                     ᯥ䨪 ⨯ union
   UNIX                                  UNIX
   unsigned arithmetic                    䬥⨪
      char type                          ⨯ unsigned char
      constant                            ⠭
      type                                ⨯
      type specifier                     ᯥ䨪 ⨯ unsigned

                              V

   vertical tab \v                       ⨪쭠 ⠡ \v
   virtual                               virtual
      base class                         㠫  
      destructor                         㠫 
      function                           㠫쭠 㭪
      function access                      㠫쭮 㭪樨
      function call                      맮 㠫쭮 㭪樨
      function, type of                  ⨯ 㠫쭮 㭪樨
      specifier                          ᯥ䨪 virtual
      user-defined conversion            㠫쭮 짮⥫᪮
                                         ८ࠧ
   void                                  void
      argument                           ⮩ ࠬ
      pointer to                         㪠⥫ ⨯ void*
      type                               ⨯ void
      type specifier                     ᯥ䨪 ⨯ void
   volatile                              volatile
      member function                    㭪-童 volatile
      operand                            ࠭ volatile
      reference                          뫪 volatile
      type                               ⨯ volatile
      type specifier                     ᯥ䨪 ⨯ volatile

                                W

   waterfall model                        ᪠
   white space                           饭 ஡
   wide-character string                 பᨬ쭠 ப

