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:

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?

I'm not sure exactly what you're trying to do, however you can overload
aPlus.

[Steven T. Hatton]

Gianni Mariani wrote:

Steven T. Hatton wrote:

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?

I'm not sure exactly what you're trying to do, however you can overload
aPlus.

Did you compile and run the code? With, and without the commented line
/**
*****uncomment* the*following*l ine*and*it*won' t*compile
*************** *************/
**//aPlus<ORDER,T,T >(a0,car);
?

I'm trying to make the second parameter const in this function template:
template <unsigned ORDER, typename T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER],**T2(&t2)[ORDER]))[ORDER];

Do you know how to do that?
--
"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:

Gianni Mariani wrote:

Steven T. Hatton wrote:

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?

I'm not sure exactly what you're trying to do, however you can overload
aPlus.

Did you compile and run the code? With, and without the commented line
/**
uncomment the following line and it won't compile
*************** ***********/
//aPlus<ORDER,T,T >(a0,car);
?

I'm trying to make the second parameter const in this function template:
template <unsigned ORDER, typename T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER], T2(&t2)[ORDER]))[ORDER];

Do you know how to do that?

Yes.

Try the code below - note the overloaded aPlus.

Also, you don't need to specify the template parameters, they can be
deduced by the compiler. i.e.

aPlus(a0,car); // this won't work with the overloading below
// but will work with the OP code.

That's what I am confused about, why are you specifying the template
parameters when they can be deduced ?
#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 T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER], const 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;
}

[Steven T. Hatton]

Gianni Mariani wrote:

Steven T. Hatton wrote:

Gianni Mariani wrote:
Yes.

Try the code below - note the overloaded aPlus.

Also, you don't need to specify the template parameters, they can be
deduced by the compiler. i.e.

aPlus(a0,car); // this won't work with the overloading below
// but will work with the OP code.
I don't understand what you mean by OP code.
That's what I am confused about, why are you specifying the template
parameters when they can be deduced ?

I don't fully understand how that works. In most circumstance where I've
been using templates I've had to specify the actual template parameters
(arguments).

#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 T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER], const T2(&t2)[ORDER]))[ORDER]
{
for(unsigned i = 0;i < ORDER; i++ )
{
t1[i] += t2[i];
}
return t1;
}

OK. I see what you're saying. I guess I was confused by the fact that very
similar code using normal array notation without the references didn't
require any overloading. I guess I've never hit the overloading issue from
this direction before.
--
"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]

Steven T. Hatton wrote:

Gianni Mariani wrote:

#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 T1, typename T2 >
T1 (&aPlus(T1(&t 1)[ORDER], const T2(&t2)[ORDER]))[ORDER]
{
for(unsigned i = 0;i < ORDER; i++ )
{
t1[i] += t2[i];
}
return t1;
}

OK. I see what you're saying. I guess I was confused by the fact that
very similar code using normal array notation without the references
didn't
require any overloading. I guess I've never hit the overloading issue
from this direction before.

I'm still confused about what this means. My understanding of making a
parameter const is that the function won't modify it. That's what I want.
Normally, I can pass a non-const variable as a const reference.

void cfun( const string& cstr)
{
cout << cstr;
}

int main()
{

string str = "This is a non-const variable\";
cfun(str);

}

So why should I have to overload that function?
--
"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:

I'm still confused about what this means. My understanding of making a
parameter const is that the function won't modify it. That's what I want.
Normally, I can pass a non-const variable as a const reference.

void cfun( const string& cstr)
{
cout << cstr;
}

int main()
{

string str = "This is a non-const variable\";
cfun(str);

}

So why should I have to overload that function?

In the OP (original post) example, it shows a const object being
assigned to a non const reference, this is not allowed.

C++ can deduce template parameters in function templates AND you can
overload functions which becomes a rather rich area of the language with
all kinds of rope to hang ourselves.

e.g.

template < typename T1, typename T2 > void f1( const T1 &, const T2 & );
template < typename T1, typename T2 > void f2( T1 &, T2 & );

struct X; struct Y;
const X & x;
Y & y;
f1( x, y ); // ==> T1 is X, T2 is Y
f2( x, y ); // ==> T1 is const X, T2 is Y

[Old Wolf]

"Steven T. Hatton" <su******@setid ava.kushan.aa> wrote:

Steven T. Hatton wrote:

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

I'm still confused about what this means. My understanding of making a
parameter const is that the function won't modify it. That's what I want.

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).
Normally, I can pass a non-const variable as a const reference.

void cfun( const string& cstr)
That is a reference to const string (not a const reference to string).

If you still don't see the difference then consider:
void foo(int *const ptr)
{ *ptr = 2; }
vs.
void foo(int const *ptr)
{ int const y = 2; ptr = &y; }
In the first one, the parameter is const but the pointed-to things
are not; in the second one, it is the other way around.

In your case it is even worse as 'const' could be applied either
to the entire array, or to its members.
int main()
{
string str = "This is a non-const variable\";
cfun(str);
}

So why should I have to overload that function?

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

[Steven T. Hatton]

Gianni Mariani wrote:

Steven T. Hatton wrote:

I'm still confused about what this means. My understanding of making a
parameter const is that the function won't modify it. That's what I
want. Normally, I can pass a non-const variable as a const reference.

void cfun( const string& cstr)
{
cout << cstr;
}

int main()
{

string str = "This is a non-const variable\";
cfun(str);

}

So why should I have to overload that function?
In the OP (original post) example, it shows a const object being
assigned to a non const reference, this is not allowed.

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

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

Why isn't car treated as const in the last statement?
C++ can deduce template parameters in function templates AND you can
overload functions which becomes a rather rich area of the language with
all kinds of rope to hang ourselves.

e.g.

template < typename T1, typename T2 > void f1( const T1 &, const T2 & );
template < typename T1, typename T2 > void f2( T1 &, T2 & );

struct X; struct Y;
const X & x;
Y & y;
f1( x, y ); // ==> T1 is X, T2 is Y
f2( x, y ); // ==> T1 is const X, T2 is Y

I'm not following this code. Is it what you had intended to write?

--
"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]

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];
?
--
"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