DaniWeb Forum Index > Software Development > C++

C++ RSS

Adding an array to an element of the array

Please support our C++ advertiser: Intel Parallel Studio Home

•

Join Date: Jul 2009

Posts: 9

Reputation: dchunt is an unknown quantity at this point

Solved Threads: 1

dchunt

Offline

Newbie Poster

Adding an array to an element of the array

Jul 14th, 2009

Now i have an array, P[8]={0,1,1,2,0,3,1,0}

And i want to add 4 separate values to each element in the array,so if i was to lookup P[2] i can access its 4 values.

I tried doing it by giving those standard values an array of itself and making each value get it through a loop but a fundamental problem occurs when assinging P[6] to those 4 values cause it kind of makes the array size 6,anyway i think i've got some concept confused.Is it possible ? How do i circumvent it ?

•

Join Date: Jun 2009

Posts: 681

Reputation: Tom Gunn has much to be proud of

Solved Threads: 133

Tom Gunn

Offline

Practically a Master Poster

Re: Adding an array to an element of the array

Jul 14th, 2009

It looks like you want a 2D array:

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
int P[] =
{
    {0, 1, 1, 2},
    {0, 3, 1, 0}
};
 
for (int x = 0; x < 2; ++x)
{
    for (int y = 0; y < 4; ++y)
        cout << P[x][y] << ' ';
    cout << '\n';
}
int P[] =
{
    {0, 1, 1, 2},
    {0, 3, 1, 0}
};

for (int x = 0; x < 2; ++x)
{
    for (int y = 0; y < 4; ++y)
        cout << P[x][y] << ' ';
    cout << '\n';
}

Is that right? Or am I missing something that makes your problem not so simple?

-Tommy (For Great Justice!) Gunn

•

Join Date: Aug 2008

Posts: 149

Reputation: monkey_king is on a distinguished road

Solved Threads: 8

monkey_king monkey_king is offline

Offline

Junior Poster

Re: Adding an array to an element of the array

Jul 14th, 2009

If the size is determined at runtime you need a full fleged dynamic memory version. Something like

 Help with Code Tags 
 c++ Syntax (Toggle Plain Text) 
#include <iostream>
 
 
int **allocs(int x,int y){
  int **ret  = new int*[x];
  for(int i=0;i<x;i++)
    ret[i] = new int[y];
  return ret;
 
}
 
 
int main(){
  int **array = allocs(4,5);
  int p = 0;
 
  for(int i=0;i<4;i++)
    for(int j=0;j<5;j++)
      array[i][j] = p++;
 
}
#include <iostream>


int **allocs(int x,int y){
  int **ret  = new int*[x];
  for(int i=0;i<x;i++)
    ret[i] = new int[y];
  return ret;

}


int main(){
  int **array = allocs(4,5);
  int p = 0;

  for(int i=0;i<4;i++)
    for(int j=0;j<5;j++)
      array[i][j] = p++;

}

•

Join Date: Oct 2007

Posts: 793

Reputation: siddhant3s has much to be proud of

Solved Threads: 135

siddhant3s siddhant3s is offline

Offline

Master Poster

Re: Adding an array to an element of the array

Jul 15th, 2009

>If the size is determined at runtime you need a full fleged dynamic memory
>version. Something like

A full fledged dynamic memory version? Is that what you call your program you just posted.
It would be so much better to rely on the standard headers than your memory leaking program.

To OP: Apart from Tom Gun advice, you may want to consider an array of a structure:

 Help with Code Tags 
 cpp Syntax (Toggle Plain Text) 
#include <iostream>
struct myStruct{
    int firstVal;
    float secVal;
    char thirdVal;
    long fourthVal;
};
int main(){
 
    myStruct P[]= {{0,  1.1,  'a',  14554},
                   {2,  2.1,  'b',  14254},
                   {4,  4.1,  'c',  14254},
                   {1,  8.1,  'd',  14254},
                   {1,  1.5,  'e',  14154},
                   {0,  1.4,  'f',  14214},
                   {2,  1.4,  'g',  14224},
                   {9,  1.7,  'h',  13254}
                  };
    std::cout<<P[6].firstVal;
};
#include <iostream>
struct myStruct{
    int firstVal;
    float secVal;
    char thirdVal;
    long fourthVal;
};
int main(){

    myStruct P[]= {{0,  1.1,  'a',  14554},
                   {2,  2.1,  'b',  14254},
                   {4,  4.1,  'c',  14254},
                   {1,  8.1,  'd',  14254},
                   {1,  1.5,  'e',  14154},
                   {0,  1.4,  'f',  14214},
                   {2,  1.4,  'g',  14224},
                   {9,  1.7,  'h',  13254}
                  };
    std::cout<<P[6].firstVal;
};

This would allow you to use heterogeneous data types.
PS: If you need dynamic allocation techniques, consider a std::vector rather than hacks such has post#2

Last edited by siddhant3s; Jul 15th, 2009 at 3:00 am.

Siddhant Sanyam
(Not posting much)
Migrate to Standard C++ :When to tell your C++ Code is Non-Standard.
Please Read before posting: How To Ask Questions The Smart Way

•

Join Date: Jun 2009

Posts: 681

Reputation: Tom Gunn has much to be proud of

Solved Threads: 133

Tom Gunn

Offline

Practically a Master Poster

Re: Adding an array to an element of the array

Jul 15th, 2009

•

It would be so much better to rely on the standard headers than your memory leaking program.

Technically it leaks memory, but realistically, it is probably not going to be run on an OS that does not free memory when a process ends. As an example of how to allocate memory for a 2D array using new[], the code is fine.

It could be better, of course.

As an example of both allocating and freeing, the code is more complete and even the technical memory leak is plugged. Good examples of heap memory should free as well as allocate. Here is the better code using the same style as monkey_king:

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
#include <iostream>
 
 
int **allocs(int x,int y){
    int **ret  = new int*[x];
    for(int i=0;i<x;i++)
        ret[i] = new int[y];
    return ret;
 
}
 
 
void deallocs(int **array, int x){
    for(int i=0;i<x;i++)
        delete[] array[i];
    delete[] array;
 
}
 
 
int main(){
    int **array = allocs(4,5);
    int p = 0;
 
    for(int i=0;i<4;i++)
        for(int j=0;j<5;j++)
            array[i][j] = p++;
 
    // check the array
    for(int i=0;i<4;i++){
        for(int j=0;j<5;j++)
            std::cout << array[i][j] << ' ';
        std::cout << '\n';
    }
 
    deallocs(array, 4);
 
}
#include <iostream>


int **allocs(int x,int y){
    int **ret  = new int*[x];
    for(int i=0;i<x;i++)
        ret[i] = new int[y];
    return ret;

}


void deallocs(int **array, int x){
    for(int i=0;i<x;i++)
        delete[] array[i];
    delete[] array;

}


int main(){
    int **array = allocs(4,5);
    int p = 0;

    for(int i=0;i<4;i++)
        for(int j=0;j<5;j++)
            array[i][j] = p++;

    // check the array
    for(int i=0;i<4;i++){
        for(int j=0;j<5;j++)
            std::cout << array[i][j] << ' ';
        std::cout << '\n';
    }

    deallocs(array, 4);

}

I think direct heap allocation should be a last resort. There are so many safer and easier ways than allocating memory yourself, and it takes too much brainpower to make sure that you are not introducing any bugs with your memory handling. A big source of bugs comes from manually handling your memory. That is why the newer languages have garbage collection.

•

you may want to consider an array of a structure:

•

If you need dynamic allocation techniques, consider a std::vector

Good advice all around, but I would advise being careful about overengineering. Programmers are good at adding bells and whistles that do nothing but make the whole program more complex. All in the name of 'future proofing' or 'being robust', even when the value of that added complexity is questionable.

The vector class is cool, and you can use it to replace arrays most of the time. Here is the same code I posted using a vector. For the same job, it is both more work and more code to do the extra work, if just a little:

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
typedef vector<int> IntVec;
typedef vector<IntVec> IntVec2D;
 
int data[] = {0, 1, 1, 2, 0, 3, 1, 0};
IntVec2D P(2);
 
P[0] = IntVec(data, data + 4);
P[1] = IntVec(data + 4, data + 8);
 
for (IntVec2D::size_type x = 0; x < P.size(); ++x)
{
    for (IntVec::size_type y = 0; y < P[x].size(); ++y)
        cout << P[x][y] << ' ';
    cout << '\n';
}
typedef vector<int> IntVec;
typedef vector<IntVec> IntVec2D;

int data[] = {0, 1, 1, 2, 0, 3, 1, 0};
IntVec2D P(2);

P[0] = IntVec(data, data + 4);
P[1] = IntVec(data + 4, data + 8);

for (IntVec2D::size_type x = 0; x < P.size(); ++x)
{
    for (IntVec::size_type y = 0; y < P[x].size(); ++y)
        cout << P[x][y] << ' ';
    cout << '\n';
}

C++0x will make that painful initialization step easier and more like the array version. But my point is that sometimes all you really need is an array. If there are only 8 values, heap memory is an extra point of failure and another thing to worry about. If the values are only ints, code to handle heterogeneous types adds no value. 'What if?' by itself is not a good reason to add complexity.

I think a better defense for the array of structs is abstraction. If the values are in groups of 4, they're related somehow, and wrapping them in an object might make the code using the groups more clear:

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
class Group // placeholder for a better name
{
    int _data[4];
public:
    // placeholder for a better constructor
    Group(int a, int b, int c, int d)
    {
        _data[0] = a;
        _data[1] = b;
        _data[2] = c;
        _data[3] = d;
    }
 
    friend ostream& operator<<(ostream& os, const Group& g)
    {
        for (int x = 0; x < 4; ++x)
        {
            os << g._data[x];
 
            if (x < 3) os << ' ';
        }
 
        return os;
    }
};
 
Group P[] = 
{
    Group(0, 1, 1, 2),
    Group(0, 3, 1, 0)
};
 
for (int x = 0; x < 2; ++x) cout << P[x] << '\n';
class Group // placeholder for a better name
{
    int _data[4];
public:
    // placeholder for a better constructor
    Group(int a, int b, int c, int d)
    {
        _data[0] = a;
        _data[1] = b;
        _data[2] = c;
        _data[3] = d;
    }

    friend ostream& operator<<(ostream& os, const Group& g)
    {
        for (int x = 0; x < 4; ++x)
        {
            os << g._data[x];

            if (x < 3) os << ' ';
        }

        return os;
    }
};

Group P[] = 
{
    Group(0, 1, 1, 2),
    Group(0, 3, 1, 0)
};

for (int x = 0; x < 2; ++x) cout << P[x] << '\n';

It is up to the programmer to decide if the abstraction is worth the code needed to implement the abstraction. dchunt did not give enough detail to know if an abstraction is worth the effort. It is possible that all he needs is an array, and anything more is unnecessary fluff.

Another situation came to mind when writing this post. If dchunt needs P to stay a 1D array, a second array of pointers into P can be used to achieve the same effect as a 2D array:

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
int P[] = {0, 1, 1, 2, 0, 3, 1, 0};
int *q[] = {&P[0], &P[4]};
 
for (int x = 0; x < 2; ++x)
{
    for (int y = 0; y < 4; ++y)
        cout << q[x][y] << ' ';
    cout << '\n';
}
int P[] = {0, 1, 1, 2, 0, 3, 1, 0};
int *q[] = {&P[0], &P[4]};

for (int x = 0; x < 2; ++x)
{
    for (int y = 0; y < 4; ++y)
        cout << q[x][y] << ' ';
    cout << '\n';
}