soraなりの日々 - fc2 -

こころにひっかかったもの

[c++,0x]コードの中心でiを理解する -第一回 0x会 my_string その後-

で、昨日、業務終了後に
メンバみんなで大反省会。

このエントリーをはてなブックマークに追加
みんなが作ったオレオレストリングのレビュー会。

結局、僕がレビューに出した最終形のソース。
hpp 一つにした。
今回、ほんと忘れてること多くていろいろ勉強になった。
複数人でこういうことやれるのは、やっぱ良いね(^^;

[kwn_string.hpp]
/**
 *  @file kwn_string.hpp
 */

#ifndef _KWN_STRING_
HPP
#define _KWN_STRING_HPP

#include <iostream>
#include <string>
#include <assert.h>

namespace kwn
{

  class string
  {
  public:
    /**
     *  @brief  constructor
     */
    string() { m_str.init(); }
    string(const std::string& str) { string(str.c_str()); }
    string(const kwn::string& str) { string(str.c_str()); }
    string(const char* c) {
      //std::cout << "------- constructor " << std::endl;
      init();
      copy(c);
    }

    /**
     *  @brief  destructor
     */
    virtual ~string() {
      //std::cout << "------- destructor " << std::endl;
      m_str.clear();
    }

  public:
    int length() const { return size(); }
    int size() const { return strlen(m_str.psz); }
    int alloc_size() const { return m_str.alloc_size; }
    void clear() { m_str.clear(); }
    const char* c_str() const { return m_str.psz; }
    bool empty() { return (!(m_str.psz && m_str.alloc_size)); }

    /**
     *  @brief  operator
     */
    string& operator=(const std::string& str) { return operator=(str.c_str()); }
    string& operator=(const kwn::string& str) { return operator=(str.c_str()); }
    string& operator=(char c) { return operator=(&c); }
    string& operator=(const char* c) { init(); copy(c); return *this; }

    string operator+(const std::string& str) const { return operator+(str.c_str()); }
    string operator+(const kwn::string& str) const { return operator+(str.c_str()); }
    string operator+(char c) const { return operator+(c); }
    string operator+(const char* c) const { kwn::string buff = *this; buff += c; return buff; }

    string& operator+=(const std::string& str) { return operator+=(str.c_str()); }
    string& operator+=(const kwn::string& str) { return operator+=(str.c_str()); }
    string& operator+=(char c) { return operator+=(&c); }
    string& operator+=(const char* c)
    {
      unsigned int n = m_str.alloc_size + strlen(c);
      allocate(n);
      m_str.memcat(m_str.psz, c, n);
      return *this;
    }

    /** this is a test code... */
    void disp() {
      if (!m_str.psz) { return; }
      std::cout << m_str.psz << std::endl;
    }

  private:
    int allocate(unsigned int size)
    {
      if (size == 0) return 0;
      unsigned int alloc = m_str.alloc(size);
      assert(alloc >= 0);
      return alloc;
    }

    int copy(const char* c)
    {
      unsigned int n = strlen(c);
      unsigned int size = allocate(n);
      assert(size >= 0);
      return m_str.memcat(m_str.psz, c, n);
    }

    void init() { m_str.init(); }

  private:
    typedef struct M_STR {
      unsigned int alloc_size;
      char* psz;

      void init() {
        alloc_size = 0;
        psz = NULL;
      }

      void clear() {
        alloc_size = 0;
        if (psz) {
          delete [] psz;
          psz = NULL;
        }
      }

      int memcat(char* out, const char* c, unsigned int size) {
        if (size == 0) return 0;
        unsigned int out_size = strlen(out);
        unsigned int start_pos = 0;
        for (unsigned int i=out_size; i<(out_size+size); i++) {
          out[i] = c[start_pos];
          start_pos++;
        }
        return out_size + size;
      }

      int alloc(unsigned int size) {
        if (size == 0) return -1;

        if (alloc_size == 0) {
          alloc_size = size + 1;
          psz = new char [alloc_size];
          assert(psz);
          return alloc_size;
        }

        M_STR buff;
        buff.init();
        buff.alloc_size = alloc_size + 1;
        buff.psz = new char [alloc_size + 1];
        assert(buff.psz);

        memset(buff.psz, 0x00, alloc_size + 1);
        memcpy(buff.psz, psz, alloc_size + 1);

        clear();
        alloc_size = buff.alloc_size + size + 1;
        psz = new char [alloc_size];
        assert(psz);

        memset(psz, 0x00, alloc_size);
        memcpy(psz, buff.psz, buff.alloc_size);

        buff.clear();

        return alloc_size;
      }
    } M_STR;

    /**
     *  @brief  class member
     */
    M_STR m_str;
  };
} // namespace kwn

#endif /* _KWN_STRING_HPP */

[main.cpp]
#include <iostream>
#include <assert.h>

#include "kwn_string.hpp"

/**
 *  @brief  test function
 *
 *   command line : g++ kwn_string.cpp
 *                : ./a.out
 *                :   hello world.
 *                :   hello world.
 *        gcc ver : 4.0.1 (Apple Inc. build 5465)
 */
int main()
{
  /** operator test. '+' */
  kwn::string str = "hello";
  kwn::string str2 = " world.";
  kwn::string str3 = str + str2;
  str3.disp();

  /** operator test. '+=' */
  kwn::string str4 = "hello";
  str4 += " world.";
  str4.disp();

  /** clear test. */
  str4.clear();
  str4.disp();

  /** multibite test. */
  kwn::string str5 = "ああああ";
  str5 += " いいいい。";
  str5.disp();

  return 0;
}



で、次はなんとチェーン構造体!(^^;
まだまだリハビリは続く。。。

環境:PowerBook G4 1.25 GHz memory 1 GB
   :gcc version 4.0.1 (Apple Inc. build 5465)
このエントリーをはてなブックマークに追加

コメント

コメントの投稿


管理者にだけ表示を許可する

トラックバック

トラックバックURLはこちら
http://sora2hs.blog70.fc2.com/tb.php/427-f3e78dbb
この記事にトラックバックする(FC2ブログユーザー)