arrays

[KingDavid]

is there a ubound function in C++?

I came up with this, but it would only work with arrays with only one diminsional arrays. how would I find the upper bound of another dimnsion.

#define UBOUND(array) (sizeof(array)/sizeof(array[0]))

are there any other array functions in C++ that are good

[parksie]

int x[5][3];
int y[10][9][8][7];
int mysize;

mysize = sizeof(x[0]) / sizeof(x[0][0]);
cout << mysize << endl;

mysize = sizeof(y[0][0][0]) / sizeof(y[0][0][0][0]);
cout << mysize << endl;

[KingDavid]

Hay tanks! I was able to get the upper bound of both 1 dim array's and 2 dim arrays



#include <iostream.h>


#define UBOUND(array) (sizeof(array)/sizeof(array[0]))
#define UBOUND2_1(array) (sizeof(array)/sizeof(array[0][0])/(sizeof(array[0]) / sizeof(array[0][0])))
#define UBOUND2_2(array) (sizeof(array[0]) / sizeof(array[0][0]))

unsigned int UBound(unsigned int SizeOfArray,unsigned int SizeOfDim1,unsigned int SizeOfType,
unsigned int NumOfDims,unsigned int DimReturned);

void main()
{
int x[30][2];
int y[22];

int dim1,dim2 = 0;

dim2 = sizeof(x[0]) / sizeof(x[0][0]);
dim1 = sizeof(x)/sizeof(x[0][0])/dim2;

cout << dim1 << "," << dim2 << endl;

cout << UBOUND2_1(x) << "," << UBOUND2_2(x) << endl;

int a,b;

a = UBound(sizeof(x),sizeof(x[0]),sizeof(x[0][0]),2,1);
b = UBound(sizeof(x),sizeof(x[0]),sizeof(x[0][0]),2,2);
cout << a << "," << b << endl;

a = UBound(sizeof(y),NULL,sizeof(y[0]),1,NULL);
cout << a << endl;
}
//===================================================================================
unsigned int UBound(unsigned int SizeOfArray,unsigned int SizeOfDim1,unsigned int SizeOfType,
unsigned int NumOfDims,unsigned int DimReturned)
{
if(NumOfDims == 1)
{

return (SizeOfArray/SizeOfType);
}
else if(NumOfDims == 2)
{
int d1,d2;
d2 = SizeOfDim1 / SizeOfType;
d1 = (SizeOfArray / SizeOfType)/d2;

if(DimReturned == 1)
return (d1);
else if(DimReturned == 2)
return (d2);
else
return (0);
}
else
{
return (0);
}
}



I wanted to create a function with only 3 paramiters but it wouldn't let me pass the array threw a void *, heres prototype


unsigned int UBound(void * array,unsigned int DimNum,unsigned int TotalNumberOfDim);


in the function every time I would try to get the size I would get errors

sizeof(array) or
sizeof(array[0])

errors...
illegal sizeof operand
subscript requires array or pointer type
'void *' : unknown size

I know very little about void pointers.
There's got to be an easier way to do this?

[HarryW]

I don't know much about templates, but I'm pretty sure you can use a template function for that:

template <class arraytype>
unsigned int UBound(arraytype * array,unsigned int DimNum,unsigned int TotalNumberOfDim)
{
//blah blah blah
}

Of course, I could be wrong.

In case you're wondering why it didn't work in the first place, I think passing void pointers (essentially variant pointers) was removed in C++ in order to enforce strong-typing, which helps trap errors at compile time. It's a good thing really.

[parksie]

No, they're still there. You have to cast them to a proper pointer type before you can use them.

[KingDavid]

I don't know anything about Templates. How do you use them?

[parksie]

Like so:

template<class T> class MyClass {
T Add(T x, T y) {
return x + y;
}
};

void main() {
MyClass<int> xxx;

cout << xxx.Add(4, 6) << endl;
}

[HarryW]

My mistake, and my apologies too. Knew there was something about em.

[parksie]

No, yours was fine -- function templates are useful too :D

[KingDavid]

How that Different from a regular class?

[parksie]

Notice the template<class T> section.

What it does is the compiler knows to use T as a parameter, and creates code for all versions of that class based on the type supplied.

[KingDavid]

I still dont understand that template stuff, but I gave it a Try.


#include <iostream.h>

template <class ARRAY>
//|------------------------------------------------------------------------------{ UBound() }---
unsigned int UBound(ARRAY * array,unsigned int DimReturn, unsigned int TotalDims)
{
unsigned int Dim1,Dim2,Dim3,Dim4,Dim5;
if(DimReturn > TotalDims)
return (0);

if(TotalDims == 1)
return (sizeof(array)/sizeof(array[0]));
else if(TotalDims == 2)
{
Dim2 = (sizeof(array[0]) / sizeof(array[0][0]));
Dim1 = (sizeof(array)/sizeof(array[0][0]))/Dim2;

if(DimReturn == 1)
return (Dim1);
else if(DimReturn == 2)
return (Dim2);
else
return (0);
}
else if(TotalDims == 3)
{
// no math yet
Dim3 = 1;
Dim2 = 1;
Dim1 = 1;

if(DimReturn == 1)
return (Dim1);
else if(DimReturn == 2)
return (Dim2);
else if(DimReturn == 3)
return (Dim3);
else
return (0);
}
else if(TotalDims == 4)
{
// no math yet
Dim4 = 1;
Dim3 = 1;
Dim2 = 1;
Dim1 = 1;

if(DimReturn == 1)
return (Dim1);
else if(DimReturn == 2)
return (Dim2);
else if(DimReturn == 3)
return (Dim3);
else if(DimReturn == 4)
return (Dim4);
else
return (0);
}
else if(TotalDims == 5)
{
// no math yet
Dim5 = 1;
Dim4 = 1;
Dim3 = 1;
Dim2 = 1;
Dim1 = 1;

if(DimReturn == 1)
return (Dim1);
else if(DimReturn == 2)
return (Dim2);
else if(DimReturn == 3)
return (Dim3);
else if(DimReturn == 4)
return (Dim4);
else if(DimReturn == 5)
return (Dim5);
else
return(0);
}
else
return (0);

}
//|------------------------------------------------------------------------{ ReturnSize() }----
template <class X>
unsigned int ReturnSize(X * ray)
{
return sizeof(ray);
}
//|------------------------------------------------------------------------------{ main() }----
void main()
{
int x[30][65];
int y[44];
int xResult;
int yResult;
int SizeOfArray;

xResult = UBound(x,2,2);// returns Corect size
cout << xResult << endl;

xResult = UBound(x,1,2);// returns 0
cout << xResult << endl;

/*
yResult = UBound(y,1,1);//error C2109
cout << yResult << endl;*/

SizeOfArray = ReturnSize(y);// returns 4 Wrong size
cout << SizeOfArray << endl;

SizeOfArray = sizeof(y);// returns Corect size: 44 * 4 = 176
cout << SizeOfArray << endl;
}
//|==================================================================={> End of Program <}=====



It don't like it when I try to pass an array with less dimensions than are in the functions, also it wont get the size of the entire array.