Re: Is it possible to create a vector of vector?

From:

Kai-Uwe Bux <jkherciueh@gmx.net>

Newsgroups:

comp.lang.c++

Date:

Tue, 03 Jun 2008 18:15:46 -0400

Message-ID:

<4845c295$0$25953$6e1ede2f@read.cnntp.org>

Kai-Uwe Bux wrote:

Ramon F Herrera wrote:

What I am saving is a set of radio button (or check mark) widgets.
Some of them belong to a logical group, which is used to provide the
mutual exclusivity. When the user clicks on one, the other N-1 are
automatically turned off.

See below how I ended up implementing the insertion. If two buttons
have the same name, they belong in the same logical group. Observant
readers will notice this is of PDF.

-RFH

------------

void insertGroupedRadioButton(RadioButtonNode *radio)
{
int i;
RadioButtonGroup *empty_vector = new RadioButtonGroup();

  for (i = 0; i < (int)ListOfRadioButton.size() && radio->name !=
ListOfRadioButton[i][0].name; i++);

  if (i == ListOfRadioButton.size()) {
    ListOfRadioButton.push_back(*empty_vector);
    }

  ListOfRadioButton[i].push_back(*radio);
}

It looks to me that

std::multimap< std::string, RadioButtonNode* >

is something that might be of interest to you. E.g.:

[snip]

There even is a way to hide the collection:

#include <string>
#include <map>
#include <cassert>
#include <iostream>
#include <ostream>

class RadioButtonNode {

  std::string the_name;

  class ButtonCollection {

    typedef std::multimap< std::string, RadioButtonNode* > map_type;

    map_type the_data;

  public:

    void insert ( RadioButtonNode * radio ) {
      the_data.insert( make_pair( radio->name(), radio ) );
    }

    void erase ( RadioButtonNode * radio ) {
      assert( radio != 0 );
      for ( map_type::iterator iter =
              the_data.lower_bound( radio->name() );
            iter != the_data.upper_bound( radio->name() ); ++iter ) {
        if ( iter->second == radio ) {
          the_data.erase( iter );
          return;
        }
      }
    }

    void on ( RadioButtonNode * radio ) {
      assert( radio != 0 );
      for ( map_type::iterator iter =
              the_data.lower_bound( radio->name() );
            iter != the_data.upper_bound( radio->name() ); ++iter ) {
        if ( iter->second == radio ) {
          iter->second->turn_on();
        } else {
          iter->second->turn_off();
        }
      }
    }

    void off ( RadioButtonNode * radio ) {
      assert( radio != 0 );
      for ( map_type::iterator iter =
              the_data.lower_bound( radio->name() );
            iter != the_data.upper_bound( radio->name() ); ++iter ) {
        if ( iter->second == radio ) {
          iter->second->turn_off();
        } else {
          iter->second->turn_on();
        }
      }
    }

  };

  ButtonCollection & the_collection ( void ) {
    static ButtonCollection dummy;
    return ( dummy );
  }

protected:

  virtual
  void turn_on ( void ) {
    std::cout << "on: " << name() << " [" << this << "]\n";
  }

  virtual
  void turn_off ( void ) {
    std::cout << "off: " << name() << " [" << this << "]\n";
  }

public:

  RadioButtonNode ( std::string const & name )
    : the_name ( name )
  {
    the_collection().insert( this );
  }

  ~RadioButtonNode ( void ) {
    the_collection().erase( this );
  }

  std::string const & name ( void ) const {
    return ( the_name );
  }

  void on ( void ) {
    the_collection().on( this );
  }

  void off ( void ) {
    the_collection().off( this );
  }

};

int main ( void ) {
  RadioButtonNode * n1 = new RadioButtonNode ( "n" );
  RadioButtonNode * n2 = new RadioButtonNode ( "n" );
  RadioButtonNode * n3 = new RadioButtonNode ( "n" );
  RadioButtonNode * n4 = new RadioButtonNode ( "n" );
  RadioButtonNode * q1 = new RadioButtonNode ( "q" );
  RadioButtonNode * q2 = new RadioButtonNode ( "q" );
  RadioButtonNode * q3 = new RadioButtonNode ( "q" );
  RadioButtonNode * q4 = new RadioButtonNode ( "q" );

  n2->on();
  std::cout << '\n';
  delete n1;
  n2->off();
}

Best

Kai-Uwe Bux