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 <mathieu.malate [e-mail] ote:

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,Nmak eFunctor(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,Nmake Functor(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" <v.Abaza...@com Acast.netwrote:

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,Nmake Functor(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 <mathieu.malate [e-mail] ote:

On Nov 6, 3:51 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

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,Nmake Functor(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 <farid.mehr...@ gmail.comwrote:

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

On Nov 6, 3:51 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

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,Nmake Functor(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 copyconstructin g.

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 <peter.koch.lar [e-mail] ote:

On 6 Nov., 18:13, terminator <farid.mehr...@ gmail.comwrote:

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

On Nov 6, 3:51 pm, "Victor Bazarov" <v.Abaza...@com Acast.netwrote:

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,Nmake Functor(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 copyconstructin g.

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 <peter.koch.lar [e-mail] ote:

>On 6 Nov., 18:13, terminator <farid.mehr...@ gmail.comwrote:
[..]

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

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" <v.Abaza...@com Acast.netwrote:
[snip]

Final code:

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

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,Nmake Functor(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" <v.Abaza...@com Acast.netwrote:
[snip]

>Final code:

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

#include <algorithm>
template <typename T, unsigned int N>
Functor<T,Nmake Functor(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