Make t2 const: T1 (&aPlus(T1(&t 1)[S],T2(&t2)[S]))[S]

[Steven T. Hatton]

In the following code, the only way I can figure out to pass an array of
const is by setting the template argument to const in the instanciation
expression. It would be (or seem to me) better if I could set that
qualifier in the function call. Can that be done?
#include <iostream>
using std::ostream;
using std::cout;

template<typena me T, unsigned ORDER>
void printArray(T array[], ostream& out=cout)
{
out << "{";
for(unsigned i = 0;i < ORDER; i++ ){
out << array[i];
if(i < ORDER - 1){ out << ",";}
}
out << "}\n\n";
}

template <unsigned ORDER, typename T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER], T2(&t2)[ORDER]))[ORDER]
{
for(unsigned i = 0;i < ORDER; i++ )
{
t1[i] += t2[i];
}
return t1;
}

template <unsigned ORDER, typename T>
void test_aPlus()
{
T a0[ORDER];
T a1[ORDER];

for(unsigned i = 0; i < ORDER; i++)
{
a0[i]=i;
a1[i]=i*i;
}

aPlus<ORDER, T,T>(a0,a1);
printArray<T,5> (a0);
printArray<T,5> (a1);

T(&ar)[ORDER]=a1;
aPlus<ORDER, T,T>(a0,ar);
printArray<T,5> (a0);
printArray<T,5> (ar);

const T(&car)[ORDER]=a1;

/**
uncomment the following line and it won't compile
*************** ***********/
//aPlus<ORDER,T,T >(a0,car);

aPlus<ORDER,T,c onst T>(a0,car);

printArray<T,5> (a0);
printArray<cons t T,5>(car);
}

int main()
{
test_aPlus<5,fl oat>();
return 0;
}

--
"If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true." - Bertrand
Russell

[Gianni Mariani]

Steven T. Hatton wrote:

Old Wolf wrote:

I think what you want is for the referred-to things to be const,
not the parameter being const. In fact it is not permitted
to make a reference const (because they cannot be reassigned anyway).

Sorry, I should have worded that better. I do understand that distinction.

So why should I have to overload that function?

The type 'array of const T2' is not the same as 'const (array of T2)'.

The following says aPlus is a function that returns a reference to an array
of type T2:
T1 (&aPlus(T1(&t 1)[S],T2(&t2)[S]))[S];

when reading C++ (and C) types you need to start from the identifier.

aPlus is a function that takes parameters t1 and t2 returning a
reference to an array of length S of T1.

Does this say aPlus is a function that returns a reference to an array of
type const T2:
T1 (&aPlus(T1(&t 1)[S],const T2(&t2)[S]))[S];
?

This is the same as the previous one except that t2 is a const T2.

[Steven T. Hatton]

Steven T. Hatton wrote:

Old Wolf wrote:

I think what you want is for the referred-to things to be const,
not the parameter being const. In fact it is not permitted
to make a reference const (because they cannot be reassigned anyway).

Sorry, I should have worded that better. I do understand that
distinction.

So why should I have to overload that function?

The type 'array of const T2' is not the same as 'const (array of T2)'.

The following says aPlus is a function that returns a reference to an
array of type T2:
T1 (&aPlus(T1(&t 1)[S],T2(&t2)[S]))[S];

Does this say aPlus is a function that returns a reference to an array of
type const T2:
T1 (&aPlus(T1(&t 1)[S],const T2(&t2)[S]))[S];
?

Sorry I meant to say "and takes arguments of reference to array of type T1
and reference to array of type (const) T2", not returns ... const ...

--
"If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true." - Bertrand
Russell

[Steven T. Hatton]

Gianni Mariani wrote:

Steven T. Hatton wrote:

type const T2:
T1 (&aPlus(T1(&t 1)[S],const T2(&t2)[S]))[S];
?

This is the same as the previous one except that t2 is a const T2.

That's what I expected.
T a0[3] = {10,20,30};
T a1[3] = {1,2,3};
T(&ar)[3]=a1;
const T(&car)[3]=a1;

aPlus(a0,car);//works
aPlus<ORDER,T,c onst*T>(a0,car) ; //works
aPlus<ORDER,T,T >(a0,car); // won't compile

I would expect the last call to be treated as:
aPlus(T(&a0)[3], const T(&a1)[3]))[3];

I think my confusion is that I don't really understand what the template
parameters are doing.

--
"If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true." - Bertrand
Russell

[Gianni Mariani]

Steven T. Hatton wrote:
....

That's what I expected.
T a0[3] = {10,20,30};
T a1[3] = {1,2,3};
T(&ar)[3]=a1;
const T(&car)[3]=a1;

aPlus(a0,car);//works
aPlus<ORDER,T,c onst T>(a0,car); //works
aPlus<ORDER,T,T >(a0,car); // won't compile

I would expect the last call to be treated as:
aPlus(T(&a0)[3], const T(&a1)[3]))[3];

I think my confusion is that I don't really understand what the template
parameters are doing.

Assuming that this is your funtion aPlus.

template <unsigned ORDER, typename T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER], T2(&t2)[ORDER]))[ORDER]

What you're doing is when you instantiate aPlus<ORDER,T,T > is creating a
function like:

T (&aPlus(T(&t1 )[ORDER], T(&t2)[ORDER]))[ORDER];

Then you try to pass "car", which is a const T array to a non const T
array reference. The compiler shoul not compile that.

[Steven T. Hatton]

Gianni Mariani wrote:

Steven T. Hatton wrote:
...

That's what I expected.
T a0[3] = {10,20,30};
T a1[3] = {1,2,3};
T(&ar)[3]=a1;
const T(&car)[3]=a1;

aPlus(a0,car);//works
aPlus<ORDER,T,c onst T>(a0,car); //works
aPlus<ORDER,T,T >(a0,car); // won't compile

I would expect the last call to be treated as:
aPlus(T(&a0)[3], const T(&a1)[3]))[3];

I think my confusion is that I don't really understand what the template
parameters are doing.

Assuming that this is your funtion aPlus.

template <unsigned ORDER, typename T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER], T2(&t2)[ORDER]))[ORDER]

What you're doing is when you instantiate aPlus<ORDER,T,T > is creating a
function like:

T (&aPlus(T(&t1 )[ORDER], T(&t2)[ORDER]))[ORDER];

Then you try to pass "car", which is a const T array to a non const T
array reference. The compiler shoul not compile that.

I now realize that I didn't actually reproduce the problem I thought I had.
The original code wouldn't compile with or without the const. Below is the
code that was originally causing problems. I had been using:
typedef T1 (&rank1T1)[ORDER];
typedef T2 (&rank1T2)[ORDER];
static rank1T1 result(rank1T1 a1, const rank1T2 a2)
template < unsigned REMAINING, unsigned ORDER, typename T1, typename T2,
typename OP>
class Array2OpAssign {
public:
typedef T1 (&rank1T1)[ORDER];
typedef const T2 (&rank1T2)[ORDER];

static rank1T1 result(rank1T1 a1, rank1T2 a2) {
OP op;
a1[ORDER - REMAINING] = op(a1[ORDER - REMAINING], a2[ORDER - REMAINING]);
return Array2OpAssign< REMAINING - 1, ORDER, T1, T2, OP>::result(a1, a2);
}
};

template < unsigned ORDER, typename T1, typename T2, typename OP>
class Array2OpAssign< 1, ORDER, T1, T2, OP> {
public:
typedef T1 (&rank1T1)[ORDER];
typedef const T2 (&rank1T2)[ORDER];// *NOTE* *DIFFERENCE*

static rank1T1 result (rank1T1 a1, rank1T2 a2){//*NOTE* *DIFFERENCE*
OP op;
a1[ORDER - 1] = op(a1[ORDER - 1], a2[ORDER - 1]);
return a1;
}
};

template <unsigned ORDER, typename T1, typename T2 >
T1 (&array2PlusAss ign(T1(&t1)[ORDER], const T2(&t2)[ORDER]))[ORDER]
{
return Array2OpAssign< ORDER,ORDER, T1, T2, Plus<T1, T2> >::result(t1,
t2);
}

template <unsigned ORDER, typename T1, typename T2 >
T1 (&array2MinusAs sign(T1(&t1)[ORDER], T2(&t2)[ORDER]))[ORDER]
{
return Array2OpAssign< ORDER,ORDER, T1, T2, Minus<T1, T2> >::result(t1,
t2);
}
}
}
/*************** *************** *************** *************** ***************
* Copyright (C) 2004 by Steven T. Hatton *
* ha*****@globals ymmetry.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
*************** *************** *************** *************** ***************/

--
"If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true." - Bertrand
Russell

[Gianni Mariani]

Steven T. Hatton wrote:
....

Does this mean you no longer have a problem ?

....

I now realize that I didn't actually reproduce the problem I thought I had.
The original code wouldn't compile with or without the const. Below is the
code that was originally causing problems. I had been using:
typedef T1 (&rank1T1)[ORDER];
typedef T2 (&rank1T2)[ORDER];
static rank1T1 result(rank1T1 a1, const rank1T2 a2)
template < unsigned REMAINING, unsigned ORDER, typename T1, typename T2,
typename OP>
class Array2OpAssign {
public:
typedef T1 (&rank1T1)[ORDER];
typedef const T2 (&rank1T2)[ORDER];

static rank1T1 result(rank1T1 a1, rank1T2 a2) {
OP op;
a1[ORDER - REMAINING] = op(a1[ORDER - REMAINING], a2[ORDER - REMAINING]);
return Array2OpAssign< REMAINING - 1, ORDER, T1, T2, OP>::result(a1, a2);
}
};

template < unsigned ORDER, typename T1, typename T2, typename OP>
class Array2OpAssign< 1, ORDER, T1, T2, OP> {
public:
typedef T1 (&rank1T1)[ORDER];
typedef const T2 (&rank1T2)[ORDER];// *NOTE* *DIFFERENCE*

static rank1T1 result (rank1T1 a1, rank1T2 a2){//*NOTE* *DIFFERENCE*
OP op;
a1[ORDER - 1] = op(a1[ORDER - 1], a2[ORDER - 1]);
return a1;
}
};

template <unsigned ORDER, typename T1, typename T2 >
T1 (&array2PlusAss ign(T1(&t1)[ORDER], const T2(&t2)[ORDER]))[ORDER]
{
return Array2OpAssign< ORDER,ORDER, T1, T2, Plus<T1, T2> >::result(t1,
t2);
}

template <unsigned ORDER, typename T1, typename T2 >
T1 (&array2MinusAs sign(T1(&t1)[ORDER], T2(&t2)[ORDER]))[ORDER]
{
return Array2OpAssign< ORDER,ORDER, T1, T2, Minus<T1, T2> >::result(t1,
t2);
}
}
}

[Steven T. Hatton]

Gianni Mariani wrote:

Steven T. Hatton wrote:
...

Does this mean you no longer have a problem ?

That's actually a funny question. :D My problems number in the transfinite.

I now have code that performs as I would like it to. I learned a lot from
this experience, and your guidance was invaluable. Thank you...and Victor
too.

I'm trying to read _C++_Templates_ :A_Complete_Gui de_, but I'm finding it
very difficult. Everytime I look in the book I get new ideas I want to
try, so I'm back to the keyboard and stumbling around for hours before I
turn the page.
--
"If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true." - Bertrand
Russell