By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
440,130 Members | 2,228 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 440,130 IT Pros & Developers. It's quick & easy.

Is it possible to create a vector of vector?

P: n/a

Newbie alert: I come from the C side, struggling to learn C++.

I need a two-dimensional data structure. I first tried a regular
vector and added the 2nd dimension with my own structs and pointers. I
couldn't make it work. Too many illegal assignments.

My next attempt was to create a vector of vector (or list of vector,
etc.). The compiler (MSVC++) doesn't seem to like such structure. I
guess I could try gcc, but let's hear the experts' opinions.

Your suggestions are most welcome.

-RFH

Jun 27 '08 #1
Share this Question
Share on Google+
19 Replies


P: n/a
LR
Ramon F Herrera wrote:
My next attempt was to create a vector of vector (or list of vector,
etc.).
This seems a very reasonable approach.

The compiler (MSVC++) doesn't seem to like such structure.
Can you please post a small example that demonstrates the problem.

Can you also be more specific about the problem that you're having.
LR
Jun 27 '08 #2

P: n/a
On 2 jun, 23:38, Ramon F Herrera <ra...@conexus.netwrote:
Newbie alert: I come from the C side, struggling to learn C++.

I need a two-dimensional data structure. I first tried a regular
vector and added the 2nd dimension with my own structs and pointers. I
couldn't make it work. Too many illegal assignments.

My next attempt was to create a vector of vector (or list of vector,
etc.). The compiler (MSVC++) doesn't seem to like such structure. I
guess I could try gcc, but let's hear the experts' opinions.

Your suggestions are most welcome.

-RFH
Mi english is not so good. Im trying to explain.

For example:

std::vector< std::vector<int myVector; // this creates a vector of
vector of integers

Now, you can do this:

std::vector<intvector;
vector.push_back(1);

myVector.push_back(vector);

then:

std::cout << myVector[0][0] << std::endl; // this prints 1

If you want to initialize a vector of vector with a fixed size use the
following line:

std::vector< std::vector<int myVector (number_of_rows,
std::vector<int>(number_of_colums, default_value));

Read http://www.sgi.com/tech/stl/Vector.html to understand the
constructor calls.

I hope you understand.

Regards
--
Mauro Ciancio
Jun 27 '08 #3

P: n/a
Ramon F Herrera wrote:
Newbie alert: I come from the C side, struggling to learn C++.

I need a two-dimensional data structure. I first tried a regular
vector and added the 2nd dimension with my own structs and pointers. I
couldn't make it work. Too many illegal assignments.

My next attempt was to create a vector of vector (or list of vector,
etc.). The compiler (MSVC++) doesn't seem to like such structure. I
guess I could try gcc, but let's hear the experts' opinions.

Your suggestions are most welcome.

-RFH
#include <vector>

int main(int argc, char *argv[]) {
std::vector<std::vector<int vectovect;
vectovect.resize(20);
for (std::vector<std::vector<int::iterator i = vectovect.begin();
i != vectovect.end(); ++i) {
i->resize(30);
}
}

--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
Jun 27 '08 #4

P: n/a
Daniel Pitts wrote:
Ramon F Herrera wrote:
>Newbie alert: I come from the C side, struggling to learn C++.

I need a two-dimensional data structure. I first tried a regular
vector and added the 2nd dimension with my own structs and pointers. I
couldn't make it work. Too many illegal assignments.

My next attempt was to create a vector of vector (or list of vector,
etc.). The compiler (MSVC++) doesn't seem to like such structure. I
guess I could try gcc, but let's hear the experts' opinions.

Your suggestions are most welcome.

-RFH

#include <vector>

int main(int argc, char *argv[]) {
std::vector<std::vector<int vectovect;
vectovect.resize(20);
for (std::vector<std::vector<int::iterator i = vectovect.begin();
i != vectovect.end(); ++i) {
i->resize(30);
}
}
Ah, listen to Mauro's advice. I didn't know about those constructors
that would ease your use :-)

--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>
Jun 27 '08 #5

P: n/a
On Jun 2, 11:50 pm, LR <lr...@superlink.netwrote:
Ramon F Herrera wrote:
My next attempt was to create a vector of vector (or list of vector,
etc.).

This seems a very reasonable approach.
The compiler (MSVC++) doesn't seem to like such structure.

Can you please post a small example that demonstrates the problem.

Well, I figured out that it is possible to create such contraptions.
There are at least two ways:

typedef vector<RadioButtonNode> RadioButtonGroup;
vector<RadioButtonGroup> ListOfRadioButton;

and the more succinct:

vector<vector<RadioButtonNode> ListOfRadioButton;

Now I have to investigate the kind suggestions from Mauro and Daniel.

Thanks, Daniel!
Grazie tanti, Mauro!

-Ramon


Jun 27 '08 #6

P: n/a
Ramon F Herrera wrote:
On Jun 2, 11:50 pm, LR <lr...@superlink.netwrote:
>Ramon F Herrera wrote:
>>My next attempt was to create a vector of vector (or list of vector,
etc.).
This seems a very reasonable approach.
>>The compiler (MSVC++) doesn't seem to like such structure.
Can you please post a small example that demonstrates the problem.


Well, I figured out that it is possible to create such contraptions.
There are at least two ways:

typedef vector<RadioButtonNode> RadioButtonGroup;
vector<RadioButtonGroup> ListOfRadioButton;

and the more succinct:

vector<vector<RadioButtonNode> ListOfRadioButton;
Your problem is here. The compiler is interpreting the closing >as a
single token. Put a space between them:

vector<vector<RadioButtonNode ListOfRadioButton;

Note the space.

>
Now I have to investigate the kind suggestions from Mauro and Daniel.

Thanks, Daniel!
Grazie tanti, Mauro!

-Ramon

Jun 27 '08 #7

P: n/a
William Xu <wi*********@gmail.comwrites:
>red floyd <no**********@example.comwrites:
>Note the space.
>Which is really annoying...
Don't worry - I think it's fixed in the next release.
Jun 27 '08 #8

P: n/a
Ramon F Herrera <ra***@conexus.netwrote:
Newbie alert: I come from the C side, struggling to learn C++.

I need a two-dimensional data structure. I first tried a regular
vector and added the 2nd dimension with my own structs and pointers. I
couldn't make it work. Too many illegal assignments.

My next attempt was to create a vector of vector (or list of vector,
etc.). The compiler (MSVC++) doesn't seem to like such structure. I
guess I could try gcc, but let's hear the experts' opinions.

Your suggestions are most welcome.
Don't make a vector of vectors. Better would be to make a matrix class
that is inherently 2D. See the FAQ for an example.
Jun 27 '08 #9

P: n/a
Daniel T. wrote:
Ramon F Herrera <ra***@conexus.netwrote:
>Newbie alert: I come from the C side, struggling to learn C++.

I need a two-dimensional data structure. I first tried a regular
vector and added the 2nd dimension with my own structs and pointers. I
couldn't make it work. Too many illegal assignments.

My next attempt was to create a vector of vector (or list of vector,
etc.). The compiler (MSVC++) doesn't seem to like such structure. I
guess I could try gcc, but let's hear the experts' opinions.

Your suggestions are most welcome.

Don't make a vector of vectors. Better would be to make a matrix class
that is inherently 2D. See the FAQ for an example.
That depends very much on whether the 2D structure is rectangular or whether
it is ragged like a text broken up into lines of different length.

For a rectangular array, a matrix like container class is probably the way
to go as it guarantees the invariants for rectangularity. For a ragged
structure, I don't see what is wrong with a vector of vectors. Of course,
one can always encapsulate that in a class to hide implementation details.
But whether that is worth the effort cannot be said without knowing the
particulars of the project. (And, for all we know, the OP might be asking
about how to implement the internals of a text buffer class.)
Best

Kai-Uwe Bux
Jun 27 '08 #10

P: n/a
LR
Ramon F Herrera wrote:
On Jun 2, 11:50 pm, LR <lr...@superlink.netwrote:
>Ramon F Herrera wrote:
>>My next attempt was to create a vector of vector (or list of vector,
etc.).
This seems a very reasonable approach.
>>The compiler (MSVC++) doesn't seem to like such structure.
Can you please post a small example that demonstrates the problem.


Well, I figured out that it is possible to create such contraptions.
There are at least two ways:

typedef vector<RadioButtonNode> RadioButtonGroup;
vector<RadioButtonGroup> ListOfRadioButton;

and the more succinct:

vector<vector<RadioButtonNode> ListOfRadioButton;

The names that you've given these things makes me wonder what it is
you're trying to do.

Why is a std::vector<RadioButtonNodea RadioButtonGroup and a
std::vector<std::vector<RadioButtonNode a ListOfRadioButton?

Perhaps a ListOfRadioButtonGroups? Or a GroupOfRadioButtonGroups?
LR
Jun 27 '08 #11

P: n/a
red floyd wrote:
Ramon F Herrera wrote:
>On Jun 2, 11:50 pm, LR <lr...@superlink.netwrote:
>>Ramon F Herrera wrote:
My next attempt was to create a vector of vector (or list of
vector, etc.).
This seems a very reasonable approach.

The compiler (MSVC++) doesn't seem to like such structure.
Can you please post a small example that demonstrates the problem.


Well, I figured out that it is possible to create such
contraptions. There are at least two ways:

typedef vector<RadioButtonNodeRadioButtonGroup;
vector<RadioButtonGroupListOfRadioButton;

and the more succinct:

vector<vector<RadioButtonNode> ListOfRadioButton;

Your problem is here. The compiler is interpreting the closing >>
as a single token. Put a space between them:

vector<vector<RadioButtonNode ListOfRadioButton;

Note the space.
This depends on what version of the compiler you have. Recent editions
have already noticed that >should work as well, accordning to the
next language revision.
Bo Persson
Jun 27 '08 #12

P: n/a
On Jun 3, 11:45 am, LR <lr...@superlink.netwrote:
Ramon F Herrera wrote:
On Jun 2, 11:50 pm, LR <lr...@superlink.netwrote:
Ramon F Herrera wrote:
My next attempt was to create a vector of vector (or list of vector,
etc.).
This seems a very reasonable approach.
>The compiler (MSVC++) doesn't seem to like such structure.
Can you please post a small example that demonstrates the problem.
Well, I figured out that it is possible to create such contraptions.
There are at least two ways:
typedef vector<RadioButtonNode RadioButtonGroup;
vector<RadioButtonGroup ListOfRadioButton;
and the more succinct:
vector<vector<RadioButtonNode> ListOfRadioButton;

The names that you've given these things makes me wonder what it is
you're trying to do.

Why is a std::vector<RadioButtonNodea RadioButtonGroup and a
std::vector<std::vector<RadioButtonNode a ListOfRadioButton?

Perhaps a ListOfRadioButtonGroups? Or a GroupOfRadioButtonGroups?

LR
Good point.

-RFH

Jun 27 '08 #13

P: n/a
On Jun 3, 7:11 am, Kai-Uwe Bux <jkherci...@gmx.netwrote:
Daniel T. wrote:
Ramon F Herrera <ra...@conexus.netwrote:
Newbie alert: I come from the C side, struggling to learn C++.
I need a two-dimensional data structure. I first tried a regular
vector and added the 2nd dimension with my own structs and pointers. I
couldn't make it work. Too many illegal assignments.
My next attempt was to create a vector of vector (or list of vector,
etc.). The compiler (MSVC++) doesn't seem to like such structure. I
guess I could try gcc, but let's hear the experts' opinions.
Your suggestions are most welcome.
Don't make a vector of vectors. Better would be to make a matrix class
that is inherently 2D. See the FAQ for an example.

That depends very much on whether the 2D structure is rectangular or whether
it is ragged like a text broken up into lines of different length.

For a rectangular array, a matrix like container class is probably the way
to go as it guarantees the invariants for rectangularity. For a ragged
structure, I don't see what is wrong with a vector of vectors. Of course,
one can always encapsulate that in a class to hide implementation details.
But whether that is worth the effort cannot be said without knowing the
particulars of the project. (And, for all we know, the OP might be asking
about how to implement the internals of a text buffer class.)

Best

Kai-Uwe Bux

You are absolutely right, Kai-Uwe. The side of my structure happens to
be completely ragged.

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);
}
Jun 27 '08 #14

P: n/a
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.:

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

class RadioButtonNode {

std::string the_name;

public:

RadioButtonNode ( std::string const & name )
: the_name ( name )
{}

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

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

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

};
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 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->on();
} else {
iter->second->off();
}
}
}

};
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" );

ButtonCollection the_collection;
the_collection.insert( n1 );
the_collection.insert( n2 );
the_collection.insert( n3 );
the_collection.insert( n4 );
the_collection.insert( q1 );
the_collection.insert( q2 );
the_collection.insert( q3 );
the_collection.insert( q4 );

the_collection.on( n2 );
}

Best

Kai-Uwe Bux
Jun 27 '08 #15

P: n/a
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
Jun 27 '08 #16

P: n/a
On Jun 3, 4:24 am, t...@eng.cam.ac.uk (Tim Love) wrote:
William Xu <william....@gmail.comwrites:
red floyd <no.spam.h...@example.comwrites:
Note the space.
Which is really annoying...

Don't worry - I think it's fixed in the next release.
It is; and here's an informative paper on it:

http://www.open-std.org/JTC1/SC22/WG...005/n1757.html
Jun 27 '08 #17

P: n/a
Kai-Uwe Bux wrote:
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:
[snip]

Come to think of it: using multiset and a custom predicate, one can avoid
storing the name string twice:

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

class RadioButtonNode {

std::string the_name;

class ButtonCollection {

typedef bool (*RadioCompare)( RadioButtonNode*, RadioButtonNode*);

static
bool radio_cmp ( RadioButtonNode* lhs, RadioButtonNode* rhs ) {
assert( lhs != 0);
assert( rhs != 0 );
return ( lhs->name() < rhs->name() );
}

typedef std::multiset< RadioButtonNode*, RadioCompare map_type;

map_type the_data;

public:

ButtonCollection ( void )
: the_data( &radio_cmp )
{}

void insert ( RadioButtonNode * radio ) {
the_data.insert( radio );
}

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

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

void off ( RadioButtonNode * radio ) {
radio->turn_off();
}

};

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;
n3->on();
}
Best

Kai-Uwe Bux
Jun 27 '08 #18

P: n/a

"red floyd" <no**********@example.coma écrit dans le message de news:
6N*****************@flpi148.ffdc.sbc.com...
Ramon F Herrera wrote:
>On Jun 2, 11:50 pm, LR <lr...@superlink.netwrote:
>>Ramon F Herrera wrote:
My next attempt was to create a vector of vector (or list of vector,
etc.).
This seems a very reasonable approach.

The compiler (MSVC++) doesn't seem to like such structure.
Can you please post a small example that demonstrates the problem.


Well, I figured out that it is possible to create such contraptions.
There are at least two ways:

typedef vector<RadioButtonNodeRadioButtonGroup;
vector<RadioButtonGroupListOfRadioButton;

and the more succinct:

vector<vector<RadioButtonNode> ListOfRadioButton;

Your problem is here. The compiler is interpreting the closing >as a
single token. Put a space between them:

vector<vector<RadioButtonNode ListOfRadioButton;

Note the space.

>>
Now I have to investigate the kind suggestions from Mauro and Daniel.

Thanks, Daniel!
Grazie tanti, Mauro!

-Ramon
When I have something like this I often use a typedef to make thing clearer

typedef vector<RadioButtonNodevecOfRadioButtonNode;
vector<vecOfRadioButtonNodeMatrixOfRadioButton;

That way you cannot struggle with the >problem.

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

Eric Pruneau
Jun 27 '08 #19

P: n/a
Hi!

Ramon F Herrera schrieb:
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);
}
Looks like a memory leak, by the way. The object to which "empty_vector"
points is neither explicitly deleted nor is it held by auto_ptr. Maybe
you just need a regular stack based instance:

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

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);
}

There is no "new" and so no leak.

Frank
Jun 27 '08 #20

This discussion thread is closed

Replies have been disabled for this discussion.