Re: How to make templated operator= more specific?

From:

Yechezkel Mett <ymett.on.usenet@gmail.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Mon, 16 Feb 2009 09:18:32 CST

Message-ID:

<147bc2b4-88e8-4b41-8409-071550df2e6c@i38g2000yqd.googlegroups.com>

On Feb 16, 2:09 am, enjoy.c...@gmail.com wrote:

Greetings.

it'll be wonderful if somebody could help me.

I have next code:

// templated class Bar is kind of BarBase.

class Foo {
public:
    template<typename T>
        Foo(T f) { bb = new Bar<T>(f); }

    template<typename T> operator Bar<T>() {
        return static_cast<Bar<T>&>(*bb);
    }

private:
    BarBase *bb;

};

I have BarBase and family of inherited Bar<type> classes. When some
Bar<type> converts to BarBase (in constructor of Foo) it needs to be
converted then back to Bar<type> (via conversion operator in Foo).
Certainly, BarBase's pointer can be converted to any of it inherited
classes, including Bar<type> (which is right) and Bar<other_type>. The
latter i'd like to exclude. That means i want compile error when Foo
used like this:

Foo<int> fi;
Bar<int> bi = fi; // Ok.
Bar<double> bd = fi; // Compile error.

What's Foo<int> ? In your code Foo is not a template. If you want Foo
to be a template simply do this:

template<class T>
class Foo {
public:
     Foo() { }

     operator Bar<T>() {
         return bb;
     }

private:
     Bar<T> bb;
};

But somehow I suspect that's not what you wanted.

Yechezkel Mett

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]