Elegant way to initialize non-static array member

[mathieu]

Hi,

Consider the following (*). Is there a way to rewrite it so that it
remains convenient (N is being recomputed when array v is modified)
*and* compiles :)

Thanks,
-Mathieu

(*)
template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);
Functor<double,Nf = v; // will not compile
//Functor<double,7f = { {0, 1, 4, 9, 16, 25, 36 } }; // need to
compute 7 by hand...

return 0;
}

[mathieu]

On Nov 6, 3:32 pm, mathieu <[e-mail]:

Hi,

Consider the following (*). Is there a way to rewrite it so that it
remains convenient (N is being recomputed when array v is modified)
*and* compiles :)

Thanks,
-Mathieu

(*)
template <typename T, unsigned int N>
struct Functor
{
T values[N];

};

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);
Functor<double,Nf = v; // will not compile
//Functor<double,7f = { {0, 1, 4, 9, 16, 25, 36 } }; // need to
compute 7 by hand...

return 0;

}

Super-ugly solution:

#define V {0, 1, 4, 9, 16, 25, 36 }
int main()
{
const double v[] = V;
const unsigned int N = sizeof(v) / sizeof(v[0]);
Functor<double,Nf = { V };
....
}

[Victor Bazarov]

mathieu wrote:

Hi,

Consider the following (*). Is there a way to rewrite it so that it
remains convenient (N is being recomputed when array v is modified)
*and* compiles :)

Thanks,
-Mathieu

(*)
template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

Add this function:

template<class T, unsigned NFunctor<T,NmakeFunctor(T (&a)[N])
{
Functor<T,Nf;
std::copy(a, a+N, f.values);
return f;
}

>
int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);
Functor<double,Nf = v; // will not compile
//Functor<double,7f = { {0, 1, 4, 9, 16, 25, 36 } }; // need to
compute 7 by hand...

Functor<double,Nf = makeFunctor(v);

>
return 0;
}

Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

Functor<double,Nf = makeFunctor(v);

return 0;
}

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[mathieu]

On Nov 6, 3:51 pm, "Victor Bazarov" <[e-mail]:

mathieu wrote:

Hi,

Consider the following (*). Is there a way to rewrite it so that it
remains convenient (N is being recomputed when array v is modified)
*and* compiles :)

....

Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

Functor<double,Nf = makeFunctor(v);

return 0;
}

nice and simple !

Thanks,
-Mathieu

[terminator]

On Nov 6, 6:18 pm, mathieu <[e-mail]:

On Nov 6, 3:51 pm, "Victor Bazarov" <[e-mail]:

mathieu wrote:

Hi,

Consider the following (*). Is there a way to rewrite it so that it
remains convenient (N is being recomputed when array v is modified)
*and* compiles :)

...

Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

Functor<double,Nf = makeFunctor(v);

return 0;
}

nice and simple !

Thanks,
-Mathieu- Hide quoted text -

- Show quoted text -

sorry to terminate, but this 'assigning to default constructed' not
initializing.
OP`s ugly solution is more efficient if 'T' has none-trivial
constructors.

regards,
FM.

[peter koch]

On 6 Nov., 18:13, terminator <[e-mail]:

On Nov 6, 6:18 pm, mathieu <[e-mail]:

On Nov 6, 3:51 pm, "Victor Bazarov" <[e-mail]:

mathieu wrote:
Hi,

Consider the following (*). Is there a way to rewrite it so that it
remains convenient (N is being recomputed when array v is modified)
*and* compiles :)

...

Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

Functor<double,Nf = makeFunctor(v);

return 0;
}

nice and simple !

Thanks,
-Mathieu- Hide quoted text -

- Show quoted text -

sorry to terminate, but this 'assigning to default constructed' not
initializing.

No. It is copyconstructing.

OP`s ugly solution is more efficient if 'T' has none-trivial
constructors.

No. Not if any modern (less than say 10 years old) C++ compiler is
used.

>
regards,

[mathieu]

On Nov 6, 6:28 pm, peter koch <[e-mail]:

On 6 Nov., 18:13, terminator <[e-mail]:

On Nov 6, 6:18 pm, mathieu <[e-mail]:

On Nov 6, 3:51 pm, "Victor Bazarov" <[e-mail]:

mathieu wrote:
Hi,

Consider the following (*). Is there a way to rewrite it so that it
remains convenient (N is being recomputed when array v is modified)
*and* compiles :)

...

Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

Functor<double,Nf = makeFunctor(v);

return 0;
}

nice and simple !

Thanks,
-Mathieu- Hide quoted text -

- Show quoted text -

sorry to terminate, but this 'assigning to default constructed' not
initializing.

No. It is copyconstructing.

OP`s ugly solution is more efficient if 'T' has none-trivial
constructors.

No. Not if any modern (less than say 10 years old) C++ compiler is
used.

Those kind of questions always kills me. I never learn assembly, and I
would have no way to know that std::copy is indeed doing the right
thing in this case. Any clue on how to see that ?

Thanks
-Mathieu

[Victor Bazarov]

mathieu wrote:

On Nov 6, 6:28 pm, peter koch <[e-mail]:

>On 6 Nov., 18:13, terminator <[e-mail]:
[..]

>>OP`s ugly solution is more efficient if 'T' has none-trivial
constructors.

No. Not if any modern (less than say 10 years old) C++ compiler is
used.

Those kind of questions always kills me. I never learn assembly, and I
would have no way to know that std::copy is indeed doing the right
thing in this case. Any clue on how to see that ?

Not sure what you mean by "the right thing", but std::copy will most
likely do 'memcpy' on arrays of POD, which is usually quite efficient;
as to non-trivial constructors, I believe 'terminator' is referring to
the inefficiency due to assigning that 'std::copy' has to do. Although
there is no way to tell whether it's inefficient until it is measured
in a real-world situation.

The problem with the macro solution is the symbol 'V' you have to live
with in the program. It is global, it has no type, and if you have to
have several of those, you quickly pollute the translation unit with
those identifiers. It's more difficult to read as well (since the 'V'
macro lives separately from the places where it is used).

Theoretical inefficiency versus code maintainability... It's a common
issue with which software designers have to deal every day.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Alex Vinokur]

On Nov 6, 4:51 pm, "Victor Bazarov" <[e-mail]:
[snip]

Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

-----------------------------------------------
Here Microsoft Visual C++ 2005 produces an error

Functor<double,Nf = makeFunctor(v);

-----------------------------------------------

>
return 0;
}

[snip]
Microsoft Visual C++ 2005 produces the following error
=========================
C2440: 'initializing' : cannot convert from 'Functor<T,N>' to
'Functor<T,N>'
with
[
T=const double,
N=7
]
and
[
T=double,
N=7
]
No user-defined-conversion operator available that can perform
this conversion, or the operator cannot be called
=============================================

Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

[Victor Bazarov]

Alex Vinokur wrote:

On Nov 6, 4:51 pm, "Victor Bazarov" <[e-mail]:
[snip]

>Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

-----------------------------------------------
Here Microsoft Visual C++ 2005 produces an error

> Functor<double,Nf = makeFunctor(v);

-----------------------------------------------

>>
return 0;
}

[snip]
Microsoft Visual C++ 2005 produces the following error
=========================
C2440: 'initializing' : cannot convert from 'Functor<T,N>' to
'Functor<T,N>'
with
[
T=const double,
N=7
]
and
[
T=double,
N=7
]
No user-defined-conversion operator available that can perform
this conversion, or the operator cannot be called
=============================================

Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

Good to know.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[terminator]

On Nov 7, 9:16 am, Alex Vinokur <[e-mail]:

On Nov 6, 4:51 pm, "Victor Bazarov" <[e-mail]:
[snip]

Final code:

template <typename T, unsigned int N>
struct Functor
{
T values[N];
};

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,NmakeFunctor(T const (&a)[N])
{
Functor<T,Nf;
std::copy(a, a + N, f.values);
return f;
}

int main()
{
const double v[] = {0, 1, 4, 9, 16, 25, 36 };
const unsigned int N = sizeof(v) / sizeof(v[0]);

-----------------------------------------------
Here Microsoft Visual C++ 2005 produces an error Functor<double,Nf = makeFunctor(v);

-----------------------------------------------

return 0;
}

[snip]

Microsoft Visual C++ 2005 produces the following error
=========================
C2440: 'initializing' : cannot convert from 'Functor<T,N>' to
'Functor<T,N>'
with
[
T=const double,
N=7
]
and
[
T=double,
N=7
]
No user-defined-conversion operator available that can perform
this conversion, or the operator cannot be called
=============================================

Why are not we going to treat intrinsic arrays as distinct coy
constructible types?
They can simply be fancied as some intrinsic template.

regards,
FM.

[James Kanze]

On Nov 7, 5:07 pm, terminator <[e-mail]:

[...]

Why are not we going to treat intrinsic arrays as distinct coy
constructible types?

Because that would break C compatibility.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[terminator]

On Nov 8, 1:27 pm, James Kanze <[e-mail]:

On Nov 7, 5:07 pm, terminator <[e-mail]:

[...]

Why are not we going to treat intrinsic arrays as distinct coy
constructible types?

Because that would break C compatibility.

including castability to appropariate pointers will remove any
incompatibilities .The internal interface of intrinsic array can be :

template <typename T, unsigned size_t n>
struct ___intrinsic_array{

___intrinsic_array(const ___intrinsic_array&);

typedef const T* ___CP;
typedef T* ___NP;
typedef volatile T* ___VP;

typedef const T& ___CR;
typedef T& ___NR;
typedef volatile T& ___VR;

inline operator ___CP()const
{return reinterpret_cast<___CP>(this);};
inline operator ___NP ()
{return reinterpret_cast<___NP >(this);};
inline operator ___VP()volatile
{return reinterpret_cast<___VP>(this);};

inline ___CR operator[](const size_t& i)const
{return *(operator ___CP()+i);};
inline ___NR operator[](const size_t& i)
{return *(operator ___NP()+i);};
inline ___VR operator[](const size_t& i)volatile
{return *(operator ___VP()+i);};

//assignment and construction can be defined as well.

};

regards,
FM.