#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "io.h"
const char *filename = "d:/database.txt";
const int ROWS = 10;
const int COLOUMS = 3;
class Data
{
public:
    Data() :
        m_nTotalColumns(COLOUMS),
        m_nTotalRows(ROWS),
        m_nCurCol(0),
        m_nCurRow(0),
        m_ppcData(NULL),
        m_fp(NULL)
    {
    }
 
    virtual ~Data() {}
 
 //create a dynamic 2 dimension char * array which points to a single data string
    bool Init() {
  m_ppcData = (char **)new char *[ROWS][COLOUMS];
  if(NULL == m_ppcData) {
      return false;
  }
        memset((void *)m_ppcData, NULL, ROWS * COLOUMS * sizeof(char *));
        return ReadFile();
    }
 
    //insert a record with all values of fields
    void Insert(const char *name, const char *Gender, const char *old) {
        if (NULL == name || NULL == Gender || NULL == old) {
            return;
        }
        //array is full
        if(++m_nCurRow >= m_nTotalRows) {
            return;
        }
        StrCpy(m_ppcData[m_nCurRow * m_nTotalColumns], name);
        StrCpy(m_ppcData[m_nCurRow * m_nTotalColumns + 1], Gender);
        StrCpy(m_ppcData[m_nCurRow * m_nTotalColumns + 2], old);
    }
 
    //updata a special data
    void Update(const unsigned int row, const unsigned int column, const char *data) {
        if(row > m_nCurRow || column >= m_nTotalColumns || NULL == data) {
            return;
        }
        StrCpy(m_ppcData[row * m_nTotalColumns + column], data);
    }
 
    //select a special data
    char *Select(const unsigned int row, const unsigned int column) {
        if(row > m_nCurRow || column >= m_nTotalColumns) {
            return NULL;
        }
        return m_ppcData[row * m_nTotalColumns + column];
    }
 
    //delete a row
    void DeleteRecord(const unsigned int row) {
        if(row > m_nCurRow) {
            return;
        }
        unsigned int i;
        unsigned int j;
        for(i = 0; i < m_nTotalColumns; i++) {
            delete [] m_ppcData[row * m_nTotalColumns + i];
            m_ppcData[row * m_nTotalColumns + i] = NULL;
        }
        //if the deleted row is not the last, i will fflush the data to the top
        if(row < m_nCurRow) {
            for(i = row; i < m_nCurRow; i++) {
                for(j = 0; j < m_nTotalColumns; j++) {
                    m_ppcData[i * m_nTotalColumns + j] = m_ppcData[(i + 1) * m_nTotalColumns + j];
                }
            }
        }
        memset((void *)(m_ppcData + m_nCurRow * m_nTotalColumns), NULL, COLOUMS * sizeof(char *));
        m_nCurRow--;
    }
 
    void display() {
        printf("**************\n");
        for(int i = 0; i < ROWS * COLOUMS; ++i) {
            if (NULL != m_ppcData && NULL != m_ppcData[i]) {
                printf("%s\n ", m_ppcData[i]);
            }
        }
    }
 
    void Save() {
        WriteFile();
    }
protected:
    const char* StrCpy(char *&dest, const char *src) {
        if(NULL == src) {
            return NULL;
        }
        //avoid copy self
        if(src == dest) {
            return dest;
        }
        //release original memory
        if(NULL != dest) {
            delete [ ]dest;
            dest = NULL;
        }
        int len = strlen(src);
        dest = new char[len + 1];
        if(NULL == dest) {
            return NULL;
        }
        return strcpy(dest, src);
    }
    //write data into file
    bool WriteFile() {
  m_fp = fopen(filename, "w+");
  if(NULL == m_fp) {
      return false;
  }
        for(int i = 0; i < ROWS * COLOUMS; ++i) {
            if (NULL != m_ppcData && NULL != m_ppcData[i]) {
                fputs(m_ppcData[i], m_fp);
                fputs(" ", m_fp);
            }
        }
        fclose(m_fp);
     return true;
    }
    //Read data From file
    //load all the data from the disk, do I need to do so?
    bool ReadFile() {
  m_fp = fopen(filename, "r+");
  if(NULL == m_fp) {
      return false;
  }
        long length = _filelength(_fileno(m_fp)) + 1;
        char *tmp = new char[length];
        if(NULL == tmp) {
      return false;
  }
        fgets(tmp, length, m_fp);
        int i = 0;
        char *pre = tmp;
        char *t = tmp;
        unsigned int pos;
        bool bIsEOF = false;
 
        for(i = 0, pos = 0; (i < length) && (pos < m_nTotalRows * m_nTotalColumns); ++i) {
            if(*t == '\0' || *t == ' ') {
                //if we come to the end of the data, break
                if(*t == '\0') {
                    StrCpy(m_ppcData[pos], pre);
                    break;
                }
                else {
                    *t = '\0';
                    StrCpy(m_ppcData[pos], pre);
                    //deal with multi spaces
                    while (*++t == ' ') {
                    }
                    pre = t;
                    pos++;
                }
            }
&nref="http://bbs.fdc.com.cn/boardlist.asp?boardid=376"                   target=_blank>Çå½­»¨Ô°                    [url="http://bbs.fdc.com.cn/boardlist.asp?boardid=277"]ÇØÔ°¾Ó[/url]                                                </DIV>              <DIV class=tabcontent id=tcontent5>                                                    p;  delete [] tmp;
        fclose(m_fp);
     return true;
    }
 
private:
    const unsigned int m_nTotalColumns;
    const unsigned int m_nTotalRows;
    unsigned int m_nCurCol;
    unsigned int m_nCurRow;
    FILE  *m_fp;
    char   **m_ppcData;
};
 
int main(int argc, char* argv[])
{
    Data d;
    if (d.Init()) {
        d.Update(2, 2, "100");
        d.Insert("Rock", "male", "24");
        d.display();
        char * p = d.Select(3, 2);
        printf("p = %s\n", p);
        d.DeleteRecord(1);
        d.display();
        d.Save();
    }
 return 0;
}
 
 

typedef vector<string> COLUMNS;
vector<COLUMS> rows;

 
#include "stdafx.h"
#pragma warning(disable:4786)
#include <vector>
#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <iterator>
#define  RECORDMAXLENGstringH 100
using namespace std;
//template <class string>
class Database
{
public:
    Database() {
    }
    virtual ~Database() {
    }
    Database(const Database &d) {
        m_vRow = d.m_vRow;
    }
    const Database& operator=(const Database& d) {
        if (this != &d) {
            this->m_vRow = d.m_vRow;
        }
        return *this;
    }
    const string& Select(const int r, const int c) {
        if(r >= m_vRow.size()) {
            throw r;
        }
        if(c >= m_vRow[0].size()) throw c;
        cout<<m_vRow[r][c]<<"\n";
        return m_vRow[r][c];
    }
    bool Update(const int r, const int c, const string & Data) {
        if(r >= m_vRow.size()) return false;
        if(c >= m_vRow[0].size()) return false;
        m_vRow[r][c] = Data;
    }
    bool DeleteRecord(const int r) {
        if(r >= m_vRow.size()) throw r;
        int i = 0;
        ROW::iterator itr = m_vRow.begin();
        while (i++ < r) {
            itr++;
        }
        m_vRow.erase(itr);
        return true;
    }
    void AddRecord(const string & name, const string& gender, const string &old) {
        COLUMN column;
        column.push_back(name);
        column.push_back(gender);
        column.push_back(old);
        m_vRow.push_back(column);
    }
    bool Init() {
        fstream fs("d:/database.txt", ios::in);
        string line;
        COLUMN column;
        //get a line from file and analyse the words in it
        while (getline(fs, line, '\n')) {
            string::size_type pos = 0;
            string::size_type pre = 0;
            string record;
            //when i find a space, it means I find a whole word
            while ((pos = line.find(' ', pos)) != string::npos) {
                record = line.substr(pre, pos - pre);
                pre = ++pos;
                //ignore multispace
                if (record != "") {
                    column.push_back(record);
                }
            }
            //deal with the last word end with '\0'
            record = line.substr(pre, string::npos);
            column.push_back(record);
            m_vRow.push_back(column);
            column.clear();
        }
        fs.close();
        return false;
    }
    bool Save() {
        fstream fs("d:/database.txt", ios::trunc | ios::out);
        COLUMN::iterator itc;
        ROW::iterator itr;
        for(itr = m_vRow.begin(); itr != m_vRow.end(); itr++) {
            for(itc = (*itr).begin(); itc != (*itr).end(); itc++) {
                fs<<(*itc)<<' ';
            }
            fs<<'\n';
        }
        fs.close();
        return false;
    }
    void display() {
        COLUMN::iterator itc;
        ROW::iterator itr;
        for(itr = m_vRow.begin(); itr != m_vRow.end(); itr++) {
            for(itc = (*itr).begin(); itc != (*itr).end(); itc++) {
                cout<<*itc<<' ';
            }
            cout<<'\n';
        }
    }
private:
    typedef vector<string> COLUMN;
    typedef vector<COLUMN> ROW;
    ROW m_vRow;
    //const static char* m_sFilename;
};
//template <class string>
//string
//const char* Database::m_sFilename = "d:/database.txt";
int main(int argc, char* argv[])
{
    Database database;
    try {
        database.Init();
        database.display();
        database.AddRecord("Chirly", "female", "18");
        database.display();
        database.Select(3, 1);
        database.DeleteRecord(5);
        database.display();
        database.Save();
    }
    catch (int i) {
        cout<<i<<"too large\n";
    }
    catch(bad_alloc &) {
        cout<<"bad alloc\n";
    }
 
 return 0;
}
 

 
    const string& Select(const int r, const int c) {
        if(r >= m_vRow.size()) {
            throw r;
        }
        if(c >= m_vRow[0].size()) throw c;
        cout<<m_vRow[r][c]<<"\n";
        return m_vRow[r][c];
    }
 

class Cell {
  bool is_null;
  std::string value;
public:
  Cell ( const std::string& init = "" )
    : is_null ( init.size() == 0 ), value ( init )
  {}
public:
  const std::string& GetValue() const
  {
    return value;
  }

  void SetValue ( const std::string& s )
  {
    value = s;
    is_null = false;
  }

  bool IsNull() const
  {
    return is_null;
  }
};

 
const Cell & Test() {
 
       return NULL; //I just want to tell something is wrong
}
 
 

Cell(const int i) {
     if(0 == i) is_null =true;
}

operator void*() const
{
  return ( is_null ) ? 0 : this;
}

void *Test() const
{
  return ( is_null ) ? 0 : this;
}