std::copy/memcpy/memmove optimizations

Question

I looked into the GCC STL (4.6.1) and saw that std::copy() uses an optimized version in case the builtin __is_trivial() evaluates to true.

Since the std::copy() and std::reverse_copy() templates are very useful for copying elements in arrays, I would like to use them. However, I have some types (which are results of template instantiations) that are structs that contain some trivial values, no pointers and have no copy constructor or assignment operator.

Is G++ smart enough to figure out that my type in fact is trivial? Is there any way in C++98 to make sure an STL implementation knows that my type is trivial?

I guess that in C++11, things will become convenient using the is_trivial<> type trait. Is this right?

Thanks!

EDIT: Sorry for being so late with this, but here is an example of a pretty simple Type class that is not trivial to GCC and llvm. Any ideas?

#include <iostream>

struct Spec;

template <typename TValue, typename TSpec>
class Type
{
public:
    TValue value;

    Type() : value(0) {}
};

int main()
{
    std::cerr << "__is_trivial(...) == "
              << __is_trivial(Type<char, Spec>) << '\n';                                                                                                                                                                                                                                    
    return 0;
}

C++03 PODs forbit default constructors too if I recall, which is probably what prevents that from being trivial. — Mooing Duck, Jan 18 '12 at 16:59
@MooingDuck: Thanks, I think that is the explanation. Together with Mathieu's answer, this answers my question. — Manuel, Jan 18 '12 at 17:21

score 5 · Accepted Answer · edited Jan 18 '12 at 22:07

5

There has been some debate over what trivial meant.

For example, your example is not trivially constructible as far as I can tell (std::is_trivially_default_constructible would return false I think).

In your case, I think you would need the new trait std::is_trivially_copyable, which is more fine grained. So... upgrade your compiler ?

edited Jan 18 '12 at 22:07

Cubbi

46,567
13
103
169

answered Jan 18 '12 at 16:58

Matthieu M.

287,565
48
449
722

score 4 · Answer 2 · answered Jan 18 '12 at 16:33

4

__is_trivial gives the right value for all types.

You can't rely on any paticular STL implementation to use it, although if the compiler vendor supplied it then it probably does contain various compiler-specific improvements behinds the scenes.

C++11's std::is_trivial is merely standardising this feature, there's no reason for an implementation not to use it.

answered Jan 18 '12 at 16:33

spraff

32,570
22
121
229

Apparently, `__is_trivial` cannot deduce whether a type is trivially copyable. :( See the example in my update. – Manuel Jan 18 '12 at 16:54

std::copy/memcpy/memmove optimizations

2 Answers2

Linked