Derive from template argument and call its copy constructor

Question

Please consider the following code:

template<class basic_ios_type>
class basic_ios_adaptor;

template<template<typename, class> class basic_ios_type, typename char_type, class traits_type>
class basic_ios_adaptor<basic_ios_type<char_type, traits_type>>
    : public basic_ios_type<char_type, traits_type>
{
public:
    typedef basic_ios_type<char_type, traits_type> base_type;

    basic_ios_adaptor(base_type const& other)
        : base_type(other)
    {
    }
};

The only available constructor is a copy constructor which takes a const reference to the base type. Example usage:

std::ofstream                    x(std::ofstream(""));  // ok
basic_ios_adaptor<std::ofstream> y(std::ofstream(""));  // error

Visual C++:

'std::basic_ios<_Elem,_Traits>::basic_ios' : cannot access private member declared in class 'std::basic_ios<_Elem,_Traits>'

Intel:

no instance of constructor "std::basic_ofstream<_Elem, _Traits>::basic_ofstream [with _Elem=char, _Traits=std::char_traits]" matches the argument list

Could anybody explain to me why this isn't working?

What does it mean to copy a stream? A stream is not a container, but a flow of data. — Lightness Races in Orbit, Jun 18 '11 at 16:12
@Yochai Timmer - It's not yoir code, it's not your coding standard. — Chris Lutz, Jun 18 '11 at 16:12
@Yochai: No. Don't start class names with capitals. Name one C++ standard type that starts with a capital. — Lightness Races in Orbit, Jun 18 '11 at 16:13
Naming conventions for templates, another discussion: http://stackoverflow.com/questions/692752/naming-conventions-for-template-types — Yochai Timmer, Jun 18 '11 at 16:25
@Tomalak - you can copy a stream (like I showed above). But I cannot do it by using my adaptor class. — 0xbadf00d, Jun 18 '11 at 16:26
From Boost naming consistency: "Template parameter names begin with an uppercase letter." http://www.boost.org/development/requirements.html#Naming_consistency — Yochai Timmer, Jun 18 '11 at 16:27
@FrEEzE2046: Actually you didn't. That "copy" was elided. In a fit of ghastliness, the compiler is allowed to elide the copy-from-temporary even if it would have "side effects". These side effects might be output to console or, in this case, a compiler error. — Lightness Races in Orbit, Jun 18 '11 at 16:28
@Yochai: Template parameter names are not the same as class template names. — Lightness Races in Orbit, Jun 18 '11 at 16:28
Sorry for the misunderstanding, didn't mean the class name. meant the template parameters. — Yochai Timmer, Jun 18 '11 at 16:33
@Tomalak: A private copy constructor can not be elided, and a compile error is not a side effect. — Dennis Zickefoose, Jun 18 '11 at 17:29
@Dennis: Then explain it. [Streams cannot be copied.](http://ideone.com/a6IO8) — Lightness Races in Orbit, Jun 18 '11 at 17:30
@Tomalak: Moves. See my answer below. I confirmed this behavior on VS2010, but the version of gcc ideone uses doesn't implement it yet. — Dennis Zickefoose, Jun 18 '11 at 17:55
@Dennis: Since [pre-0x GCC won't elide this like I thought it would](http://ideone.com/KK2tC), I'm now inclined to agree with you. Regardless, "it isn't a copy" is still accurate, and streams still cannot be copied. — Lightness Races in Orbit, Jun 18 '11 at 18:39

score 4 · Accepted Answer · edited May 23 '17 at 11:48

4

You can't copy streams, because their copy constructor is private (or more specifically, the copy ctor from basic_ios).

See also this question.

edited May 23 '17 at 11:48

Community

1
1

answered Jun 18 '11 at 16:09

Xeo

129,499
52
291
397

score 4 · Answer 2 · answered Jun 18 '11 at 16:10

4

STL streams cannot be copy constructed, thats your problem.

answered Jun 18 '11 at 16:10

Node

3,443
16
18

Why it's working for std::ofstream? (`std::ofstream x(std::ofstream(""))`) – 0xbadf00d Jun 18 '11 at 16:27
@FrEEzE2046: It's not. You're not copying. See my comment on your question. – Lightness Races in Orbit Jun 18 '11 at 16:29

Dennis Zickefoose · Answer 3 · 2011-06-18T17:40:42.777

As has been said, standard streams are not copiable. However, in C++0x, they are moveable. Depending on what compiler/setting you are using, that is likely the behavior you are seeing. ofstream x(std::ofstream("x")); creates a temporary ofstream, and then moves that temporary into the named ofstream. This is perfectly legal. However, in your code, you define a copy constructor, so no move can take place. Copies are still forbidden, so the compiler stops you.

So, for your class, you would also have to move, not copy. ios_base_adaptor(base_type&& other) : ofstream(std::move(other)) { }

score 0 · Answer 4 · answered Jun 18 '11 at 17:24

Okay, what I want to achieve is the possibility to create any basic_ios<> class I derive from. So, in my example I just wanted to create a ofstream for the specified file.

It's possible in the following way:

template<template<typename, class> class basic_ios_type, typename char_type, class traits_type>
class basic_ios_adaptor<basic_ios_type<char_type, traits_type>>
    : public basic_ios_type<char_type, traits_type>
{
public:
    typedef basic_ios_type<char_type, traits_type> base_type;

    template<class create>
    basic_ios_adaptor(create& create)
    {
        create(static_cast<base_type*>(this));
    }
};

It should be safte to pass a pointer to the base class, because at this stage it's already allocated and constructed.

Usage:

struct construct
{
    void operator()(std::ofstream* o) { 
        *o = std::ofstream("file");
    }
};

construct c;
basic_ios_adaptor<std::ofstream> y(c);

Any other workaround?

It's an answer, because it seems to work. But this depends on the compiler if he elides it or not (see comments on my initial post). — 0xbadf00d, Jun 18 '11 at 18:55
While my comments regarding elision were wrong, streams still cannot be copied. I think what you're doing here is _moving_, which is new to C++0x. As long as you're aware of it, and as long as your code is aware of it, you might be ok... — Lightness Races in Orbit, Jun 18 '11 at 19:44

Derive from template argument and call its copy constructor

4 Answers4