Pastable version of PHP associative array class for C++

<pre class='prettyprint' language='c++'>#include &lt;map&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
using namespace std;

template &lt;class Tk&gt;
class head
{
  private:
   map&lt;Tk, unsigned int&gt; m_head;
  public:
   //optionally use another map to define the column indeces
   head(map&lt;Tk, unsigned int&gt;&amp; column_defs)
     : m_head(column_defs){ }
   
   //define the columns based on the data in this vector  
   head(const vector&lt;Tk&gt;* pvct_columns = NULL)
   {
      if (pvct_columns != NULL){
         for (unsigned int i = 0; i &lt; pvct_columns-&gt;size(); ++i)
         {
            m_head[ (*pvct_columns)[i] ] = i;
         }                
      }                
   }   
  
   bool exists(const Tk&amp; col){
      return m_head.find(col) != m_head.end();
   }
   
   /**
    * Get the value if it exists,
    * Useful if we do not know the column headers associated with this
    * associative array
    *
    * @param i the index 
    * @return pointer to the Tk column it found, NULL if does not exist
    */
   const Tk* value_to_key(unsigned int i)
   {
     bool found = false;
     map&lt;Tk, unsigned int&gt;::iterator it = m_head.begin(); // internalMap is std::map
     while(it != m_head.end())
     {
        found = (it-&gt;second == i);
        if(found)
                return &amp;it-&gt;first;
        ++it;
     }
     return NULL;    
   }
   
     
   void undefine(const Tk&amp; col){
         m_head.erase(m_head.find(col));
   }
   unsigned int count(){ return m_head.size(); }
   inline unsigned int size(){ return m_head.size(); }
   //return the column index
   unsigned int&amp; column(const Tk&amp; col){ return m_head[col]; }
   
   unsigned int&amp; operator[](const Tk&amp; col){ return m_head[col]; }
   
   const Tk&amp; operator[](unsigned int i)
   {
      const Tk* pstr = value_to_key(i);
      if (pstr == NULL){ throw 1; }
      return (*pstr);
   }
};

template &lt;class Tk, class Tv&gt;
class row
{
   head&lt;Tk&gt;* m_phead;
   vector&lt; vector&lt;Tv&gt; &gt;* m_pvdata; ///pointer to the full data array
  public:
   unsigned int m_row;
  public:
    explicit row(head&lt;Tk&gt;* phead, vector&lt; vector&lt;Tv&gt; &gt;* pvdata, unsigned int row_index = 0)
       : m_phead(phead), m_pvdata(pvdata), m_row(row_index)
    { }
  //this is the second bracket[row][key]
  Tv&amp; operator[](const Tk&amp; key) const
  {
     return (*this)[ m_phead-&gt;column(key) ];  
  } 
  
  //this is the second bracket[row][index]
  Tv&amp; operator[](unsigned int index) const
  {
     return (*m_pvdata)[m_row][index];  
  }

vector &lt;Tv&gt;&amp; operator=(std::vector&lt;Tv&gt;&amp; rhs)
  {
     if (rhs.size() &gt; m_phead-&gt;size())
     {
         throw Tk( &quot;vector has more entries than columns&quot; );
     }
     else
     {
        (*m_pvdata)[m_row] = rhs;
     }
     return (*m_pvdata)[m_row];
  }

vector &lt;Tv&gt;&amp; operator=(const std::vector&lt;Tv&gt;&amp; rhs) const
  {
     if (rhs.size() &gt; m_phead-&gt;size())
     {
         throw Tk( &quot;vector has more entries than columns&quot; );
     }
     else
     {
        (*m_pvdata)[m_row] = rhs;
     }
     return (*m_pvdata)[m_row];
  }
};

/**
 * This contains the core data, the vector of all the rows, 
 * and the column header information 
 */
template &lt;class Tk, class Tv&gt;
class assoc_array
{
  private:
    vector&lt; vector&lt;Tv&gt; &gt; m_data;
    head&lt;Tk&gt; m_head;
    row&lt;Tk,Tv&gt; m_temp_row;
    
  public:
    assoc_array(unsigned int num_rows = 0, const vector&lt;Tk&gt;&amp; vct_columns = vector&lt;Tk&gt;(1), int fill_value = 0)
    : m_data(num_rows, vector&lt;Tv&gt;(vct_columns.size(), fill_value)), m_head(&amp;vct_columns), m_temp_row(&amp;m_head, &amp;m_data)
    {
    }
    
    
    const Tk&amp; get_column(unsigned int i){ return m_head[i]; }
    const int numCols(){ return m_head.size(); }
    
    
    void define_column(const Tk&amp; col, unsigned int index){
       m_head[col] = index;
    }
    void undefine_column(const Tk&amp; col){ 
       m_head.undefine(col);
    }
    
  //access either using a column name or column index -- optimized (not 2 different entries like PHP)
    Tv&amp; data(unsigned int row, unsigned int col){ return m_data[row][col]; }
    Tv&amp; data(unsigned int row, const Tk&amp; scol){
          Tv col = m_head.column(scol); 
          return m_data[row][col]; 
    }
    
    const int numRows(){ return m_data.size(); }
    inline const int count(){ return numRows(); }
    
    
    
    const row&lt;Tk, Tv&gt;&amp; operator[](unsigned int row)
    {
      //set the temporary row index so the next time 
      m_temp_row.m_row = row;
      return m_temp_row; 
    }
};

#include &lt;iostream&gt;

char* rword (char *word)
{
  int len = rand () % 6 + 1;
  word [len] = 0;
  while (len) word [--len] = 'a' + rand () % 26;
  return word;
}

template&lt;class Tk, class Tv&gt;
void print(assoc_array&lt;Tk, Tv&gt;&amp; ary)
{
   for (int j = 0; j &lt; ary.numCols(); j++)
   {
     cout &lt;&lt; ary.get_column(j) &lt;&lt; &quot;\t&quot;;
   }
   cout &lt;&lt; endl;
   for (int j = 0; j &lt; 40; ++j){ cout &lt;&lt; &quot;-&quot;; }
   cout &lt;&lt; endl;

for (int i = 0; i &lt; ary.numRows(); ++i)
   {
      for (int j = 0; j &lt; ary.numCols(); j++)
      {
         cout &lt;&lt; ary[i][j] &lt;&lt; &quot;\t&quot;;
      }
      cout &lt;&lt; endl;
   }
}

int main()
{
   assoc_array&lt;string, int&gt; ary;
   
   vector&lt;string&gt; cols(5);
   cols[0] = &quot;text&quot;;
   cols[1] = &quot;book&quot;;
   cols[2] = &quot;chapter&quot;;
   cols[3] = &quot;verse&quot;;
   cols[4] = &quot;rowid&quot;;
   assoc_array&lt;string, int&gt; big_ary(5, cols, 8888);
   //set some data
   big_ary.data(2, &quot;rowid&quot;) = 2;
   big_ary.data(2, &quot;chapter&quot;) = 15;
   
   for (int i = 0; i &lt; big_ary.numRows(); ++i)
   {
     std::vector&lt;int&gt; vct(big_ary.numCols(), i);
     big_ary[i] = vct;
   }

print(big_ary);
   
   system(&quot;PAUSE&quot;);

}

/** output **
text    book    chapter verse   rowid
----------------------------------------
0       0       0       0       0
1       1       1       1       1
2       2       2       2       2
3       3       3       3       3
4       4       4       4       4
**/</pre>
<a href="http://www.refactormycode.com/codes/991-php-associative-array-class-for-c" style="color:#fff" title="As seen on RefactorMyCode.com"><img alt="Small_logo" src="http://www.refactormycode.com/images/small_logo.gif" style="border:0" /></a>

Refactor :my => 'code'

Recent

Popular

Pastable version of PHP associative array class for C++