1

我正在使用 Stroustrup 的包装模板类：

template<class T, class Pref, class Suf>
class Wrap {
protected: 
    T* p;
    int* owned;
    void incr_owned() { if (owned) ++*owned; }
    void decr_owned() { if (owned && --*owned == 0) { delete p; delete owned; } }

    Pref prefix;
    Suf suffix;
public:
    Wrap(T& x, Pref pr, Suf su)
        :p(&x), owned(0), prefix(pr), suffix(su) { } 

    Wrap(T* pp, Pref pr, Suf su)
        :p(pp), owned(new int(1)), prefix(pr), suffix(su) { } 

    Wrap(const Wrap& a)
        :p(a.p), owned(a.owned), prefix(a.prefix), suffix(a.suffix)
        { incr_owned(); }

我将其子类化以创建线程安全对象：

template<class DSP> class DspWrap : public Wrap<DSP, void(*)(), void(*)()> {
protected:
    CriticalSection* criticalSection;

public:
    DspWrap(DSP& x) : Wrap<DSP, void(*)(), void(*)()>(x, &DspWrap::prefix, &DspWrap::suffix) { 
    }

    DspWrap(DSP* pp) : Wrap<DSP, void(*)(), void(*)()>(pp, &DspWrap::prefix, &DspWrap::suffix) { //compiler error here
    }

但是当在创建对象的行中DspWrap<PpmDsp> wrap = DspWrap<PpmDsp>(new PpmDsp());出现以下错误error C2664: 'Wrap<T,Pref,Suf>::Wrap(T &,Pref,Suf)' : cannot convert parameter 1 from 'PpmDsp *' to 'PpmDsp &'

但为什么它调用了错误的构造函数？实际上有一个构造函数PpmDsp*，那么它为什么要尝试调用PpmDsp&呢？

提前致谢

4

2 回答 2

0

&DspWrap::prefix是类型Pref*。您将它传递给 的构造Wrap函数，它需要一个类型为 的对象Pref。相反，传递DspWrap::prefix在语法上是正确的。

但是，DspWrap::prefix当它传递给 的构造函数时尚未初始化Wrap，因此实际上之后调用Wrap::prefix具有未定义的行为。

于 2013-09-25T15:38:20.873 回答
0

我不确定您在将成员初始化为自己时要做什么，但是您需要为基类提供适当的构造参数，而基类成员*他们自己*不是这样做的方法。

一旦我声明了两个真正的函数，prefix其余suffix的都可以正常工作，并且基础构造函数正确初始化。因为我没有你的定义，CriticalSection或者DSP我有点不得不伪造这个样本，但是....

#include <iostream>

typedef int CriticalSection;

template<class T, class Pref, class Suf>
class Wrap {
protected:
    T* p;
    int* owned;
    void incr_owned() { if (owned) ++*owned; }
    void decr_owned() { if (owned && --*owned == 0) { delete p; delete owned; } }

    Pref prefix;
    Suf suffix;
public:
    Wrap(T& x, Pref pr, Suf su)
        :p(&x), owned(0), prefix(pr), suffix(su) { }

    Wrap(T* pp, Pref pr, Suf su)
        :p(pp), owned(new int(1)), prefix(pr), suffix(su) { }
};

template<class DSP> class DspWrap : public Wrap<DSP, void(*)(), void(*)()> {
protected:
    CriticalSection* criticalSection;

    // implemenations of these
    static void prefix_fn() {};
    static void suffix_fn() {};

public:
    DspWrap(DSP& x)
        : Wrap<DSP, void(*)(), void(*)()>(x, &prefix_fn, &suffix_fn)
        , criticalSection(new CriticalSection)
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

    DspWrap(DSP* pp)
        : Wrap<DSP, void(*)(), void(*)()>(pp, &prefix_fn, &suffix_fn)
        , criticalSection(new CriticalSection)
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

struct MyDSP { };

int main()
{
    MyDSP dsp;
    DspWrap<MyDSP> wrap1(dsp);

    MyDSP *dsp2 = new MyDSP;
    DspWrap<MyDSP> wrap2(dsp2);
    return 0;
}

输出

DspWrap<MyDSP>::DspWrap(DSP &) [DSP = MyDSP]
DspWrap<MyDSP>::DspWrap(DSP *) [DSP = MyDSP]
于 2013-09-25T15:35:48.863 回答