template< ARR1, ARR2, VAL > doit( ARR1 < ARR2 > )

[jabbah]

yeah i know that the title is not really a question - sorry - i fail to put my question into one sentence so i put it into a storry:

background is i am using two different 'ARRAY's in my code.
(ie. things with access in constant time via operator[] )
namely std::vector and something from another library. but, still i do mostly the same things one both so, a while ago i decided to implement most in templates so i can easily change between them.

so e.g. i have things like

inline unsigned int size(const ThirdPartyArray<T>& arr ){
  return static_cast<unsigned int>( arr.getSize() );
}
inline unsigned int size(const std::vector<T>& arr ){
  return arr.size();
}

which wraps the different methods to determine the size and allows me to do something like that:

template< typename ARRAY, typename VAL >
unsigned int doit(ARRAY& arr, VAL v){
...
}

however i would want to also work on multidimensional arrays in that way

template< typename ARR1, typename ARR2, typename VAL>
void doit(ARR1 < ARR2 >& arr, VAL v){
  for ( unsigned int i=0; i < size(arr); i++ ){
    doit(arr[i],v);
  }
}

but my compiler instructs me that this is obviously not the right way to implement that. (complains on the first '<' in 'void doit( ARR1 <'.

Can someone point me in the right direction? or is that just not possible with templates? or is it not possible to understand my question?

[weaknessforcats]

Probably all you need is:

template<typename T, typename VAL>
void doit(T* arr, VAL v){ 
  for ( unsigned int i=0; i < size(arr); i++ ){ 
    doit(arr[i],v); 
  } 
} 

All arrays are one dimensional (read this http://bytes.com/topic/c/insights/77...rrays-revealed. At the end of the article is an example that's close to what you are asking for.

You would need arguments for each dimension size.

Then you iterate the multidimensional array using a series of nested loops.

[jabbah]

All arrays are one dimensional

ok, agreed. a matter of terminology right?! so i shall call these beasts arrays of arrays or the like.

read this ...

mhm no i dont really see how that relates to my problem with the templates. maybe using the word 'array' is missleading. Im not talking about c-style arrays like int[8] but rather meant it as a general term for constant-time-random-access ahm ... things. (and within the class of such things i clearly prefer things that have an understanding about their own size, like std::vector, unlike c-style arrays) Also Im not necessarily facing 'matrix'-like things, ie the vectors in the vector may be of different size.


@weaknessforcats
No, didnt work for me. Here a compilable example (i only changed from pointer to reference in your proposal)

#include <iostream>
#include <vector>
using namespace std;
 
template< typename T >
inline unsigned int size(const std::vector<T>& arr )
{
    return arr.size();
}
 
// for array of val
template< typename ARRAY, typename VAL >
void doit(ARRAY& arr, VAL v)
{
    for ( unsigned int i = 0 ; i < size(arr); i++ )
    {
        arr[i] = v;
        cout << arr[i] << " ";
    }
    cout << "\n";
}
 
// for array of array
template<typename ARRAY, typename VAL>
void doit(ARRAY& arr, VAL v)
{ 
    for ( unsigned int i=0; i < size(arr); i++ ){ 
        doit(arr[i],v); 
    } 
}
 
void main_vecvectemplate()
{
    cout << __FUNCTION__ << "\n";
 
    std::vector<double> v(3);
 
    doit(v,0.0);
 
    std::vector< std::vector<double > > v2;
    v2.push_back( std::vector<double>(2) );
    v2.push_back( std::vector<double>(3) );
 
 
    // raises an error because the compiler tries to instantiate doit for array of val and complains about
    // binary = with right hand side double and
    // binary << for vector
    doit(v2, 1.1);
 
    cout << __FUNCTION__ << " done\n";
}
 

I guess i could rename doit for array of val to ... doit_for_array_of_val or doitm or whatever. Im only wondering whether there is a more elegant solution. My idea with

template< typename ARR1, typename ARR2, typename VAL>
void doit(ARR1 < ARR2 >& arr, VAL v)

was an attempt to kind of specialize doit, since doit for array of array is one special case and doit for array of val is another special case, where i would hope the compiler is able to deduce which one is appropriate

[weaknessforcats]

You keep using the word array and you mention C arrays as though they were different from C++ arrays, which
they are not.

An array means a specific thing: A collection of elements continguous in memory.

You use the [] to define the number of elements, like:

int arr[5];
 

for an collection of 5 contiguous integers.

This:

int arr1[5][3];
 

still has 5 elements not 15!. Each element is an array of 3 ints.

When you iterate these arrays, you iterate over 5 elements each time. In the case of the second array, each element may require an inner iteration over 3 ints.

When these are passed to functions, only the name of the array is passed.
The name of the array is always the address of element 0. In the
first case the name of the array is the the address of arr[0], an int. So your
function needs an int* argument. In the second case, the address of element 0 is the address of an array of 3 int so your function needs and int (*)[3] argument.

That means a) you can't generalize arrays and b) you always have to specify the
number of elements.

The only workaround is to pass in the first case &arr[0] (address of an int) and
& arr1[0][0] (address of an int). Then your function needs and int* argument
for the array plus a) the number of ints plus in the second case b) the number
of 3-integer arrays.

You will still need two functions since the number of arguments varies.

Passing arrays to functions incurs decay of array (Google this). It means
when viewed from inside the function the array structure has been lost since all you have is an address.

Finally, a vector is required to implement an array. You are using vectors.
Therefore, you are using arrays and have to follow the rules of arrays.

Just because the vector is a class does not change its internal implementation.
All it does is provide a sets of methods to control the array, which you would have to write anyway to control an array you declared out in public. You still have access to the array:

vector<int> v(5);
v[0] = 3;
int* ptr = &v[0]; //address of the 3
 

Now you can bypass the vector methods and work woth the array like you did in C.

In your doit example, you handle the various cases by overloading doit. Call it
with an int* and an int for the number of elements and the compiler will call the
doit with int* and int arguments. Call it with and int* and two arguments for the
two dimensions and the compiler will call that doit. From the caller's viewpoint,
doit has been generalized. It works with either two or three arguments. That fact
that there are two functions is irrelevant. Like the Wizard of Oz said "Pay no
attention to the man behind the curtain".

[jabbah]

phew! I do honestly appreciate the effort you put up to try and help me but man we are really drifting apart here!!

yes I do know that

# C arrays are not different from C++ arrays
# an array is a collection of elements continguous in memory
# You use the [] to define ...
# int arr1[5][3] has 5 elements not 15
# The name of the array is always the address of element 0
# Passing arrays to functions incurs decay of array
# a vector is implement via an array. im using vectors = im using arrays

the most relevant difference between array and vector in my opinion is that a vector knows about its size and i can truely forget about the fact that there is an array living inside of the vector. this really enables me to not pay any more attention to the man(array) behind the curtain(vector)!

Yes I could - bypass the vector methods and work with the array like I did in C. - but I do desperately NOT want to!

I do understand that IF i would be using an int* and overloading then the signatures of the two doit's would differ:
# doit(int* arr, int dim)
# doit(int* arr, int dim1, int dim2)
and that would work.

The point is that
a) I dont want to use arrays, since they offer no benefit over vector (but the contrary!)
b) I can not use doit(int* arr, int dim1, int dim2), because I do frequently face the situation that my datastructure is not rectangular, but like in the example of

std::vector< std::vector<double > > v2;
v2.push_back( std::vector<double>(2) );
v2.push_back( std::vector<double>(3) );

the 'rows' in the 'matrix' v2 do not all have the same number of entries.


uff.

Maybe I really caused this missunderstanding by my use of the word array - the problem is that im really running out of words here. so let me propose the following notation

# c-array
denotes datastructures like
int[3] a;
as they occur in C/C++ programming language

# vector
denotes the datastructure provided by STL: std::vector<>

# array
denotes the concept of a datastructure that allows constant time access to a random element. That concept occurs all through out computer science and i guess any selfrespectable programming language provides something like that.
c-array's and vector's are examples of that. just like eg java.util.Vector

From now on I will strictly stick to that notation.

So im trying to come back to my question.

Im using std::vector and I would want to provide functions that perform some operation on all elements of a vector<int> or on all elements of vector<vector<int> >.
I have achieved that by using different names: doit and doitm

// for array of val
template< typename ARRAY, typename VAL >
void doit(ARRAY& arr, VAL v)
{
    for ( unsigned int i = 0 ; i < size(arr); i++ )
    {
        arr[i] = v;
        cout << arr[i] << " ";
    }
    cout << "\n";
}
 
// for array of array
template<typename ARRAY, typename VAL>
void doitm(ARRAY& arr, VAL v)
{ 
    for ( unsigned int i=0; i < size(arr); i++ ){ 
        doit(arr[i],v); 
    } 
}
 

Im wondering whether template specialization would offer a way to use the name doit for both functions.
Or maybe someone has any other suggestion that is superior to the doit/doitm approach, whereas i dont think a doit(int* arr, int dim)/doit(int* arr, int dim1, int dim2) is superior to doit/doitm.

[Savage]

Perhaps a recursion can do what you want.

template<typename ARRAY,typename VAL>
void doit(ARRAY &arr,VAL v,unsigned int dimensions=1)
{
     if(dimensions==1)
     {
        for ( unsigned int i = 0 ; i < size(arr); i++ )
        {
            arr[i] = v;
            cout << arr[i] << " ";
        }
         cout << "\n";
     }
     else
     {
          for ( unsigned int i=0; i < size(arr); i++ ){ 
               doit(arr[i],v,dimensions-1); 
     } 
}
 

Another benefit of this is that it will work for an array of any dimension.

[jabbah]

@Savage
ok. right! i thought that doitm() would work for multiple dimensions (hence m) but of course thats not true! it only works for dim=2. so its rather a doit2().

so yeah this

void doit(ARRAY &arr,VAL v,unsigned int dimensions=1)

is better than doit/doitm

[jabbah]

now i got it!

i was always thinking along specializations for
doit( ARRAY<WHATEVER>, VALUE ) for multiple dimensions and
doit( ARRAY<VALUE>, VALUE ) for the one-dimensional case

but more appropriate is
doit( ARRAY<WHATEVER>, VALUE ) for any dimension and
doit( VALUE, VALUE ), ie

template< typename ARRAY, typename VAL >
void set_all(ARRAY& arr, const VAL& val)
{
    for ( unsigned int i = 0 ; i < size(arr); i++ )
    {
        set_all( arr[i], val );
    }
}
template< typename T >
void set_all(T& lhs, const T& rhs)
{
    lhs = rhs;
}
 

[weaknessforcats]

[quote=jabbah]
# vector
denotes the datastructure provided by STL: std::vector<>
[quote]
Please understand that this datastructure must be an array.

The only reason vector knows the size of the array is becuse it creates the array on the heap for a known number of elements and keeps that number tucked away. You could do the same thing yourself and not use vector at all.

[jabbah]

Please understand that this datastructure must be an array.

i do.

The only reason vector knows the size of the array is becuse it creates the array on the heap for a known number of elements and keeps that number tucked away.

ok.

You could do the same thing yourself and not use vector at all.

ok.


you have helped me greatly in the past weaknessforcats. in more than one occasion! this time it seems we dont even manage to talk about the same thing. thanks anyway!