Printable View
Hi!
I want to make a get() function for a two-dimensional array in my class.
Like this:
Code:class MyClass {
public:
getArray(); // <-----How do I define and decleare this function?
private:
int array[5][5];
};
So, I would like to use the function like this:
Code:int main() {
MyClass foo;
// *Decleare the array somehow* <-------how would I do this?
array = foo.getArray();
return 0;
}
I'm guessing you want to use something like:
I may not know how to achieve that, but you could instead. workaround is simply using int* as the return type/declaration type. Then add getWidth() and getHeight() functions.Code:array[1][3] = 40;
Assuming you have differing dimensions:Code:array[1 * getHeight() + 3]
then the native index:Code:int arr[H][W];
arr[y][x] = v;
Code:arr[ y * H + W ] = v;
std::vector< std::vector<type> > foo()
Actually, there was another post just now, with a similar problem, so with no life of mine i made a sample for you:
thank this guy King Mir:Code:typedef int array2d [5][5];
array2d arr;
array2d* get_arr()
{
return &arr;
}
int main()
{
int i;
int *t;
t = (int*)(arr);
for (i = 0; i < 25; i++) {
t[i] = i;
}
printf("%d\n", arr[3][2]);
array2d *a1;
a1 = get_arr();
printf("%d\n", (*a1)[3][2]);
return 0;
}
http://cboard.cprogramming.com/showthread.php?t=103106
Use a vector. It's far easier.
No global variables either.
This is C++, not C...
A vector of vectors may have too much overhead to be a replacement for small multidimensional stack array. (I believe there are cases where it is justified not to want dynamic allocations.)
By the way, do you want to return a copy of the array?
In that case, it might be meaningful to use an out parameter (the contents are copied to a suitable array provided by the caller).
If you don't want a copy, then you might try returning a pointer to pointer (int**).
-----
Best advice depends on what exactly you are doing this for...
Returning a pointer to pointer won't work, since you loose the dimension of the array. You will need to indicate at least the last dimension of the array.Quote:
Originally Posted by anon
gcc (and g++) doesn't seem to allow functions returning arrays.
--
Mats
I can give you a very simple Java-verison of what I want.
I will comment it well, so non-java people can read it.
So, I would like a C++ verison of this java-code:
Code:
class MyClass {
private int[][] iPointer = new int[5][5]; // This makes a new array of int, and let iPointer point to it
// This is the get-function. It returns a pointer to the array
public int[][] getArray() {
return iPointer;
}
}
class MainClass {
public static void main(String[] args) { // This is the java int main()
MyClass myclass = new MyClass(); // Run the above class.
int[][] anotherPointer; // Decleare a pointer that should be pointing to a 2-dimensional int array
anotherPointer = myclass.getArray(); // Set the pointer to point to the array returned
// Then, I want to be able to do this, on the array returned.
// (This pointer points to the iPointer member in myclass)
anotherPointer[0][0]=5;
anotherPointer[0][1]=3;
}
}
If you want Java approach, it's easy if you use std::vector. You can return std::vector, so essentially, you can return an array that way.
Well, I know.
But there should be a way to do this without vectors too...?
Let's say I would use this code-block inside a game-loop, using vectors. That would hurt. If you catch my drift :)
Then use references.
Create the vector inside the class and let getArray return a reference to it.
So there is no way to do it without vectors?
(Hm, maybe I should've posted in the C-forum instead, given the devlopement of this thread. Oh well..)
Why? Why are you so anti-vector?
You should be able to return a pointer to an array in a class. Let me work on it for few minutes.
Not very pretty:
--Code:#include <iostream>
typedef int myarray[5][5];
class myclass
{
myarray arr;
public:
myclass() {
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 5; j++)
arr[j][i] = i * j;
}
}
friend std::ostream &operator<<(std::ostream &os, const myclass &c);
myarray * getArray()
{
return &arr;
}
};
std::ostream &operator<<(std::ostream &os, const myclass &c)
{
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 5; j++)
os << c.arr[j][i] << " ";
os << std::endl;
}
return os;
}
int main()
{
myclass c;
int (*p)[5][5];
std::cout << c;
p = c.getArray();
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 5; j++)
std::cout << (*p)[j][i] << " ";
std::cout << std::endl;
}
return 0;
}
Mats
Why? Something smells bad here...Quote:
Originally Posted by Drogin
I believe that it is not possible to return an array in both C and C++.Quote:
gcc (and g++) doesn't seem to allow functions returning arrays.
Yes, so we can return a pointer to the first element of the array. Since I am not sure of the syntax, I shall take the liberty of using a typedef:Quote:
Returning a pointer to pointer won't work, since you loose the dimension of the array. You will need to indicate at least the last dimension of the array.
Code:class MyClass {
public:
typedef int(*ArrayType)[5];
ArrayType getArray()
{
return array;
}
private:
int array[5][5];
};
See above. The thing is, vectors can make things easier.Quote:
So there is no way to do it without vectors?
This is part of C++'s C heritage, so you will face the same problem.Quote:
(Hm, maybe I should've posted in the C-forum instead, given the devlopement of this thread. Oh well..)
Yes, I think it relates back to the "you can't assign arrays" that C also has in it's basic setup.Quote:
Originally Posted by laserlight
--
Mats
If you are sure you want to be able to modify the array from outside the class, I don't see much point in making it private in the first place.
I don't really need to modify it. I just want to check the data. So it can be defined as const pointer.Quote:
Originally Posted by anon
Are you sure that you don't want to "check the data" in a member/friend function?Quote:
Originally Posted by Drogin
--
Mats
You still haven't addressed why you are so anti-vector, however.
Have you considered that not everyone should have to motivate their design decisions with you?Quote:
Originally Posted by Elysia
--
Mats
Have you considered that I want to know why the OP is so anti-vector?
I'm not the only one suggesting the idea to use a vector. Laserlight proposed (or clarified) that they made things easier, so I'd like to know (especially with Java background!) why someone is so anti-vector.
>> Have you considered that I want to know why the OP is so anti-vector?
Start a new thread or send a PM. I too think a vector makes sense in many cases, but there's no need to clutter a thread with multiple posts about it when the OP is obviously going in a different direction.
But it's also part of suggesting a solution. Or helping solve the problem or gaining a better understanding of the problem.
Is the OP afraid of C++ objects? Is the OP afraid of vector? Is it speed concerns? Is it memory concerns?
And this is only the 2nd. If it gets ignored after the 2nd time, then maybe it's time to start evaluating if it's ignored on purpose.
Even so, it's also somewhat rude to ignore posts, especially from people trying to help. It's all for the sake of getting a better understanding of the problem.
My personal choice would be to flatten the 2D array first and return a pointer to that, if some other container wasn't available.
I believe someone demonstrated this but it bears repeating:
Not a complete example at all, but I think you should use or build a matrix class.Code:#include <cstddef>
#include <cstring>
class stupidmatrix
{
public:
stupidmatrix (std::size_t rowheight, std::size_t colwidth):
_rows(rowheight),
_cols(colwidth),
_impl(new int [_rows*_cols])
//If you had an existing 2D-array, you could just allocate a new pointer like this,
//copy the data over, and then delete and reassign the old pointer. Try this assignment
//in a loop:
//newp[row*_rows+i] = oldp[row][i];
{
}
~stupidmatrix ()
{
delete[] _impl;
}
int * get ()
{
return _impl;
}
private:
int * _impl;
const std::size_t _rows;
const std::size_t _cols;
};
Make the check a member function. No need to return anything.Quote:
Originally Posted by Drogin
>> Not a complete example at all, but I think you should use or build a matrix class.
I know it's not a complete example, but since so many people miss it I would prefer to have it include a comment about or disabling of copying.
>> But it's also part of suggesting a solution.
I don't mind it being suggested once, or being repeated when tacked on to another point that is relevant to the discussion.
>> And this is only the 2nd.
You mentioned vectors in five separate posts and added almost nothing else of value. The OP responded that he or she did not want to use vectors and even intimated why. The OP also made it clear that he or she did not think further discussion of vectors was relevant. So, take the hint. It is their loss if a vector would be the best choice but they choose to avoid it. I'm ashamed to be cluttering the thread even further, but I think a public explanation is best here.
There's nothing wrong with using arrays, if you don't want vectors. It's definitely possible to return an array, but it looks ugly:
This is more direct and simple than returning a pointer to a pointer to an integer. You could also make the array dimensions into a macro so you never need to repeat the '[5][5]'.Code:class MyClass
{
private:
/* I assume you want the const-ness of this
array to be implementation defined: */
int array[5][5];
/* Otherwise, you can of course explicitly
make it mutable or const, and get rid of
the unecessary getter function, below: */
public:
/* Const getter-function: */
const int (&getArray() const)[5][5] { return array; }
/* Non-const getter: */
int (&getArray())[5][5] { return array; }
};
int ** getArray()
this doesn't help you keep track of the array dimensions though if they're ever something other than 5 and 5; you'll need something like:
unsigned int get1DLength()
and
unsigned int get2DLength(int 1dPos)
this is probably not the best way to do it tho.
You should avoid using magic numbers.
You mentioned that you want to return the array so that you can check it; Well a much better way to do this would be to make a public method to do the checking for you, thus simplifying implementation code as well as putting the array checking in its proper place. This concept is sometimes called encapsulation or information hiding.
eg:Code:...
public:
int checkArray(); // Returns some status code
...
Hi Elysia,Quote:
Originally Posted by Elysia
This would work well and all, but it really isn't going to help them understand why you can't "return a 2d array" in C++.
When people learn C++ they generally learn about how strings are represented in memory as null-terminated byte arrays before they learn to use the std::string class, right? Same idea here, IMO.
Okay folks, thanks a lot for your time, and the wonderful replies.
laserlight's solution worked fine, so that was all I needed, thanks a ton :)
To Elysia: I'm sorry I couldnt adress you earlier, I was kinda busy.
I am not anti-vector. Using vectors would surely pose no problem for me for the use I want, and it was an excelent suggestion.
However, I would also like to know how to make it without vectors, in case I would ever need to do that. For example because of memory or speed concerns.
And just out of curiosity. I've been trying for hours to get it to work, so I wanted to see the "correct" solution.
>> When people learn C++ they generally learn about how strings are represented in memory as
>> null-terminated byte arrays before they learn to use the std::string class, right?
If they are they aren't being taught in the most effective way. They should be taught strings first (and vectors).
Oh, but was not under impression that it was to learn, but rather to get it working with a good solution.Quote:
Originally Posted by BMJ
I see.Quote:
Originally Posted by Drogin
But you could have mentioned it earlier.
Anyway, no harm done.
you can do it with multiple layers of indirection.Quote:
Originally Posted by drogin
I suppose. The C++ classes I've assisted have always been for people with no prior programming experience, sometimes I forget that not everybody is in the same situation. :)Quote:
Originally Posted by Daved
>> sometimes I forget that not everybody is in the same situation.
Either way, they should be taught strings first, IMO. Stroustrup and many other C++ experts agree.
In my opinion, it would make more sense to use regular getter functions that provide more indirect access to the array, instead of turning a reference to the whole private array itself. This promotes better encapsulation.
You can even use the getter functions to do bounds-checking when accessing the array, to make code safer.Code:class MyClass
{
public:
int array[5][5];
public:
MyClass() { /* ... */ }
int& getArray(std::size_t index_x, std::size_t index_y)
{ return array[index_x][index_y]; }
/* And a const version: */
const int& getArray(std::size_t index_x, std::size_t index_y) const
{ return array[index_x][index_y]; }
};
int main()
{
MyClass obj;
const MyClass c_obj;
obj.getArray(0,0) = 1;
c_obj.getArray(0,0) = 1; // Error: assignment of read-only location
}
But only marginally. Clients of the getters depend on the implementation detail of a 2d array. If and when that implementation changes, it breaks code that uses the getter.Quote:
Originally Posted by rudyman
Where does Stroustrup explain this because I'd genuinely love to have more insight.Quote:
Originally Posted by Daved
Thanks. :)
Learning Standard C++ as a New Language
>> Thanks.
Your welcome.