(Qt/C++) Multiple Values in int Array

You can declare a multidimensional array:

int array[5][3];
array[0][0] = 10; array[0][1] = 20; array[0][2] = 30;
array[1][0] = 44; array[1][1] = 55; array[2][2] = 66;
...

or create an array of an ad-hoc struct:

struct tuple_3int
{
    int x, y, z;
    tuple_3int() {} 
    tuple_3int(int X, int Y, int Z) : x(X), y(Y), z(Z) {}
};

tuple_3int array[5];
array[0] = tuple_3int(10, 20, 30);
array[1] = tuple_3int(44, 55, 66);

Or, if you are using C++11, you can use the new tuples, and declare an array of tuples of 3 ints:

#include <tuple>

std::tuple<int, int, int> array[5];
array[0]=std::make_tuple(10, 20, 30);
array[1]=std::make_tuple(44, 55, 66);

You can achive your goal at diffrent ways:

1. Create a triple class of int's, and create array of this class.

i.e.

class triple {
int x;
int y;
int z;
public:
triple (int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
};

triple array[SIZE]; array[0] = triple (1,2,3);

1. Enter the values of the int ordinary and refer for every 3 sequential cells as 1 index.

i.e.

array[0] = 10;    
array[1] = 44;   
array[2] = 20;   
array[3] = 55;   
array[4] = 30;   
array[5] = 66;  

Than 0-2 indexes will be your first cell, 3-5 the seconde and so on.

1. Creat a 2D array.

i.e.

int array [SIZE][3];
array [i][0] = 1;
array [i][1] = 2;
array [i][2] = 3;

Assuming you can use C++11, then a std::vector of std::tuple seems to be a simple approach, here is a simple example:

#include <iostream>
#include <vector>
#include <tuple>

int main()
{
    std::vector<std::tuple<int,int,int>> tupleVector ;

    tupleVector.push_back( std::make_tuple( 10, 20, 30 ) ) ;
    tupleVector.push_back( std::make_tuple( 44, 55, 66 ) ) ;

    std::cout << std::get<0>( tupleVector[0] ) << ":" << std::get<1>( tupleVector[0] )  << ":" << std::get<2>( tupleVector[0] )  << std::endl ;
    std::cout << std::get<0>( tupleVector[1] ) << ":" << std::get<1>( tupleVector[1] )  << ":" << std::get<2>( tupleVector[1] )  << std::endl ;
}

A non C++11 example could use a struct to hold the slot data, you could stick with arrays but std::vector is simpler and will cause you less headaches in the long run:

#include <iostream>
#include <vector>
#include <tuple>

struct slot
{
    int x1, x2, x3 ;

    slot() : x1(0), x2(0), x3() {}   // Note, need default ctor for array example
    slot( int p1, int p2, int p3 ) : x1(p1), x2(p2), x3(p3) {}  
} ;

int main()
{
    std::vector<slot> slotVector ;

    slotVector.push_back( slot( 10, 20, 30 ) ) ;
    slotVector.push_back( slot( 44, 55, 66 ) ) ;

    std::cout << slotVector[0].x1 << ":" << slotVector[0].x2 << ":" << slotVector[0].x3 << std::endl ;

    slot slotArray[5] ;

    slotArray[0] = slot( 10, 20, 30 ) ;
    slotArray[0] = slot( 44, 55, 66 ) ;

    std::cout << slotArray[0].x1 << ":" << slotArray[0].x2 << ":" << slotArray[0].x3 << std::endl ;
}

Why don't you use 2D array ?! if number of elements to be saved won't be equal in every cell you can use array of vector or array of list

for example

vector<int> array[5];