• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            linux&c++ R&D

            programing is a pleasure!

            Using std::basic_string the extensible way

            Problem:
            Using std::basic_string the extensible way
            I'm writing a class that contains a string. But I decided to make it
            more extensible and turn it into a class template:
            template<typename CharT>
            class My
            {
                 std::basic_string<CharT> text;
            };

            How do I operate on such a string, so that it will work for any valid
            instantiation of basic_string? For example, I'd like to append some text
            to the end of the string or check if the first letter is lowercase.
            Currently I'm doing:
                 text += "some other text";
            For wstring I should probably do:
                 test += L"some other text";
            How do I do it in a generic way?
            Solution:
            That depends on the meaning of these literals.
            Are these only some selected literals of the
            corresponding character type with a special
            meaning? If so, than a character-depending
            policy/traits class would be reasonable, which
            would be explicitely specialized for the corresponding
            value, e.g.
            template <typename CharT> 
            class MyTraits; 
            template 
            <> 
            struct MyTraits
            <char> 
              
            static const char* append() 
                
            return "some other text"
              }

            }

            template 
            <> 
            struct MyTraits
            <wchar_t> 
              
            static const wchar_t* append() 
                
            return L"some other text"
              }
             
            }

            template
            <typename CharT> 
            class My 

               std::basic_string
            <CharT> text; 
               typedef MyTraits
            <CharT> Traits; 
               
            void foo() 
                  text 
            += Traits::append(); 
               }
             
            }


            Otherwise you could only declare the member
            functions in the My class template and explicitely
            specialize them for the corresponding character
            type:
            template<typename CharT> 
            class My 

               std::basic_string
            <CharT> text; 
            public
               
            void foo(); // Only declared, not defined 
            }

            template
            <> 
            void My<char>::foo() 
              text 
            += "some other text"
            }
             
            template
            <> 
            void My<wchar_t>::foo() 
              text 
            += L"some other text"
            }
             

            In both cases some preprocessor magic
            can help reducing the redundancies.
            ----------------------------------------------------------------------------
            How about writing a helper function to convert a narrow string literal
            to an arbitrary basic_string<T>: 
               // A template to 'widen' a string literal 
               
            template < class CharT > 
               std::basic_string
            <CharT> widen( char const* str ) 
                 std::basic_stringstream
            < CharT > s; 
                 s 
            << str; return s.str(); 
               }
             
            Then you can 
            do 
               test 
            += widen<char>"foo bar" ); 
            or 
               test 
            += widen<wchar_t>"foo bar" ); 

            as appropriate.
            You could even make it a constructor, but it's probably best to make it
            explicit in the code when you want this widening.

            posted on 2007-04-25 23:39 丑石 閱讀(800) 評論(0)  編輯 收藏 引用 所屬分類: C++ problem and solution

            My Links

            Blog Stats

            News

            常用鏈接

            留言簿(1)

            隨筆分類(13)

            隨筆檔案(17)

            文章檔案(1)

            相冊

            收藏夾(1)

            Friends' blog

            useful sites

            搜索

            積分與排名

            最新評論

            閱讀排行榜

            評論排行榜

            精品国产乱码久久久久久呢| 国产精品九九久久免费视频| 亚洲国产天堂久久综合网站| 99久久国产综合精品网成人影院 | 精品久久久久久亚洲精品| 亚洲欧美日韩久久精品第一区| 久久国产色av免费看| 久久人人爽人人爽人人AV东京热| 要久久爱在线免费观看| 久久亚洲精品成人AV| 99久久er这里只有精品18| 国产一级持黄大片99久久| 久久中文字幕视频、最近更新| 久久综合久久自在自线精品自| 国产情侣久久久久aⅴ免费| 99久久国产主播综合精品 | 88久久精品无码一区二区毛片 | 99久久婷婷国产综合精品草原| 亚洲欧洲中文日韩久久AV乱码| 亚洲综合伊人久久大杳蕉| 美女久久久久久| 久久国产精品成人片免费| 久久综合色老色| 97久久精品人人做人人爽| 99久久做夜夜爱天天做精品| 色婷婷综合久久久久中文字幕| 国产午夜久久影院| 久久久久久伊人高潮影院 | 久久精品视频一| 精品国产婷婷久久久| 日韩一区二区久久久久久| 国内精品久久国产大陆| 99久久无色码中文字幕人妻| 久久精品国产色蜜蜜麻豆| 久久精品这里只有精99品| 国产亚洲婷婷香蕉久久精品| 久久精品蜜芽亚洲国产AV| 亚洲中文精品久久久久久不卡| 久久久久亚洲AV无码专区首JN| 久久天天躁狠狠躁夜夜av浪潮| 狠狠精品干练久久久无码中文字幕|