How to put initialized structs in a struct?

Question

I have a struct :

typedef struct 
{      
    int nNum;     
    string str;    
}KeyPair;

Then I initialize my struct into something like this:

KeyPair keys[] =  
{    
    {0, "tester"},        
    {2, "yadah"},        
    {0, "tester"}  
};   

And yet, let's say a number of other initializations:

KeyPair keysA[] =  
{    
    {0, "tester"},        
    {2, "yadah"},        
    {0, "tester"}  
};   



KeyPair keysB[] =  
{    
    {0, "testeras"},        
    {2, "yadahsdf"},        
    {3, "testerasss"}  
};   



KeyPair OtherkeysA[] =  
{    
    {1, "tester"},        
    {2, "yadah"},        
    {3, "tester"}  
};

and like 20 more of 'em.

Now, how do I create another struct and initialize it such that it contains these initiazed KeyPairs?

The reason for this is because I will repetitively call a function whose parameters would come for these structs. And I DO NOT want to do it this way:

pressKeyPairs( keys, sizeof( keys) / sizeof( keys[0] ) );
pressKeyPairs( keysA, sizeof( keysA) / sizeof( keysA[0] ) );
pressKeyPairs( keysB, sizeof( keysB) / sizeof( keysB[0] ) );
pressKeyPairs( OtherkeysA, sizeof( OtherkeysA) / sizeof( OtherkeysA[0] ) );
and so on...

So I would like to just loop through a struct containing these inilialized instantiations of KeyPairs...

OR I would like to put these initialized instances of KeyPairs into a vector and just loop through the vector... How do I do that?

Answer 1

Assuming that you have a fixed number key pairs, you could use a structure member function:

typedef struct KeyPairs {
    KeyPair keysA[3];
    KeyPair keysB[3];
    KeyPair otherKeysA[3];

    void init() {
       keysA[0].nNum = 0;
       keysA[0].str = "tester";
       keysA[1].nNum = 2;
       keysA[1].str = "yadah";
       keysA[2].nNum = 0;
       keysA[2].str = "tester";

       // and so on for other keys
    }
} KeyPairs;

Then use it like so:

KeyPairs pairs;
pairs.init();

Answer 2

How about doing real C++ and using constructors ?

(note that typedefs are implicits for structs in C++)

struct KeyPair
{
    int nNum;     
    string str;

    public:
    KeyPair() {}
    KeyPair(int n, string s) : nNum(n), str(s) {}

};

And then use another struct :

struct TripleKeyPair
{
    KeyPair keys[3];

    TripleKeyPair() 
    {
        // Your initialisation code goes here
    }
};

And finally, I wouldn't advice using names such as :

KeysA, KeysB, KeysC ...

Arrays are exactly for this. Why note use std::vector ?

Answer 3

How about using "null" objects as delimiters in the array? You would have to use constructors though:

struct KeyPair
{
    KeyPair() : fIsEmpty(true) {}
    KeyPair(int nNum_, const char *szStr) : nNum(nNum_), str(szStr), fIsEmpty(false) {}

    int nNum;
    string str;
    bool fIsEmpty;
};

Then you can initialize it like this:

KeyPair allKeys[] = 
{
    KeyPair(0, "testeras"),      
    KeyPair(2, "yadahsdf"),
    KeyPair(3, "testerasss"),
    KeyPair(),
    KeyPair(0, "tester"),
    KeyPair(2, "yadah"),
    KeyPair(3, "tester"),
    KeyPair(1, "moreyadah"),
    KeyPair()
};

And the iteration is trivial if you implement a kind of strlen() analog for KeyPair object array.