Thread: Two Hard-coded Arrays into One 2-Dimensional Vector

Are you looking for something like this:

Code:

int main() {	
    int typeArray[3] = {55,66,77};
    int valArray[3] = {1,2,3};
    vector< vector <int> > myVector(3, vector<int> (2, 0));

    for (int i = 0; i < 3; i++) {
        myVector[i][0] = typeArray[i];
        myVector[i][1] = valArray[i];
    }

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            cout << myVector[i][j] << ' ';
        }
        cout << '\n';
    }

    return 0; 
}

OK, my code is revised and it is now working. I am ready for Phase 2 of this program.
However, before taking it there, I'd like to receive input on the following questions:

1. How does the "for loop" method differ from the "push_back", or "assign" methods?
For example, using "assign" to populate the vector with an array:

Code:

myVector.assign (typeArray,typeArray + 3);

I still don't know how I'd use this for a 2-Dimensional vector...
Please let me what you think of these alternatives just to be thorough.

Here's the REVISED code and output using DevCPP:

Code:

#include <iostream>
#include <vector> 
#include <Windows.h>
#include <algorithm> 

using namespace std;  int main() 
{ 
    int typeArray[3] = {55,66,77}; 
    int valArray[3] = {1,2,3};  

    // re: vector: 3 = LENGTH or NUMBER of ROWS; 2 = WIDTH or NUMBER of COLUMNS; //  0 = VALUE all cells are initialized to.
     vector< vector <int> > myVector(3, vector<int> (2,0));  
     for (int i = 0; i < sizeof(typeArray)/sizeof(typeArray[0]); i++) 
       {     
           myVector[i][0] = typeArray[i]; 

             for (int j = 0; j < sizeof(valArray)/sizeof(valArray[0]); j++) 
               {          
                  myVector[j][1] = valArray[j]; 
               } 
        }   
         cout << myVector[0][0] << " " << myVector[1][0]<< " " << myVector[2][0]<< endl;     
         cout << myVector[0][1] << " " << myVector[1][1]<< " " << myVector[2][1]<< endl;     

     system("Pause"); 
     return 0;  }

-----------------------------------
OUTPUT:

55 66 77
1 2 3

--------------------
please confirm about using either "assign" or "push-back" methods, and after that I'll submit the next phase which is one array is 4 elements, and the other is 13 elements. Thanks!

Your nested loops don't make any sense. Look back at the code I posted before. Notice that it only uses ONE loop, not two nested loops. In your code, the inner loop is being executed 3 times and each time is doing exactly the same thing, filling the 2nd "column" of the vector with values from valArray. In other words, you don't need the inner loop at all (meaning that you didn't understand the code I posted before).

You could use assign if you switched the dimensions of your vector-of-vectors, like this:

Code:

    vector< vector <int> > myVector(2, vector<int> (3, 0));

    myVector[0].assign(typeArray, typeArray + 3);
    myVector[1].assign(valArray, valArray + 3);

Note that the 2 and 3 have been switched in the definition of myVector.

push_back could be used if you didn't already set the size of the inner vector, since push_back actually adds an element to the end of the vector each time.

The example I gave in post #5 should be:

Code:

    vector< vector <int> > myVector(2);  // create 2 "rows"

    myVector[0].assign(typeArray, typeArray + 3);  // assign typeArray to first row
    myVector[1].assign(valArray, valArray + 3);    // assign valArray to second row

So, I want to clarify that "myVector[0]" is the first ROW and "myVector[1] is the second ROW, yes?

Yes, that's correct, although you could also correctly think of them as the first and second "columns" since it's arbitrary. More precisely, each of myVector[0] and myVector[1] holds a vector-of-ints, which you are imagining as "rows".

Originally Posted by oogabooga

Are you looking for something like this:

This should also work...

Code:

int main()
{	
    int typeArray[3] = {55,66,77};
    int valArray[3] = {1,2,3};
    const size_t SizeOfTypeArray = sizeof(typeArray) / sizeof(typeArray[0]);
    const size_t SizeOfValArray = sizeof(valArray) / sizeof(valArray[0]);

    vector< vector <int> > myVector(3, vector<int> (2, 0));

    std::copy(typeArray, typeArray + SizeOfTypeArray, myVector[0].begin());
    std::copy(typeArray, valArray + SizeOfValArray, myVector[1].begin());
}

OK, now I'm making the arrays two different sizes and haven't figured out exactly how to populate the vector correctly.
Although I'm coding with "for loops" in this one, I also tried the"assign" method which was basically the same output.

Here's the code and output:

Code:

int main()			
{	
    
    
    int typeArray[4] = {55,66,77,88};
    int valArray[13] = {1,2,3,4,5,6,7,8,9,10,10,10,11};
    
    // 4 = LENGTH or NUMBER of ROWS; 13 = WIDTH or NUMBER of COLUMNS;
    //  0 = VALUE all cells are initialized to
    vector< vector <int> > myVector(4, vector<int> (13,0));

          for (int i = 0;  i < 4;  i++) 
         {
            myVector[i][0] = typeArray[i];

              for (int j = 0;  j < 13;  j++) 
              {
                myVector[1][j] = valArray[j];
              }
        }

       // print to screen
        for (int i = 0; i < 4; i++)
          {         
            for (int j = 0; j < 13; j++)
             { 
              cout << myVector[i][j] << ' ';
              }         
              cout << '\n';
          }

Before I post the output, I realize that if I want "valArray" to populate to the right of COLUMN 0,0 I should put [j][1], however, I keep getting an error when I do that.
Here's the OUTPUT:
55 0 0 0 0 0 0 0 0 0 0 0 0
1 2 3 4 5 6 7 8 9 10 10 10 11
77 0 0 0 0 0 0 0 0 0 0 0 0
88 0 0 0 0 0 0 0 0 0 0 0 0
Press any key to continue . . .
-------------------------------------------
Please advise, I'm not quite getting it yet, thanks!

As we've discussed, there are many possible ways of doing this. Here's what I might do.

Code:

#include <iostream>
#include <vector>
using namespace std;

#define ASIZE(a) (sizeof(a)/sizeof(*(a)))

typedef vector<int> VI;
typedef vector<VI>  VVI;

int main() {	
    int typeArray[] = {55,66,77,88};
    int valArray[]  = {1,2,3,4,5,6,7,8,9,10,10,10,11};
    VVI  v;

    v.push_back(VI(typeArray, typeArray + ASIZE(typeArray)));
    v.push_back(VI(valArray,  valArray  + ASIZE(valArray)));

    for (size_t i = 0; i < v.size(); i++) {
        for (size_t j = 0; j < v[i].size(); j++)
            cout << v[i][j] << ' ';
        cout << '\n';
    }
}