我想部分专门化一个现有的模板,我无法改变(std::tr1::hash)基类和所有派生类.原因是我使用奇怪的重复模板模式进行多态,并且哈希函数在CRTP基类中实现.如果我只想部分专门用于CRTP基类,那么它很简单,我可以写:

namespace std { namespace tr1 {

template <typename Derived>
struct hash<CRTPBase<Derived> >
{
    size_t operator()(const CRTPBase<Derived> & base) const 
    { 
        return base.hash(); 
    }
};

} }

但是这种专门化只与实际的派生类不匹配CRTPBase<Derived>.我想要的是一种编写部分特化的方法,Derived当且仅当它来源于CRTPBase<Derived>.我的伪代码是

namespace std { namespace tr1 {

template <typename Derived>
struct hash<typename boost::enable_if<std::tr1::is_base_of<CRTPBase<Derived>, Derived>,
    Derived>::type>
{
    size_t operator()(const CRTPBase<Derived> & base) const 
    { 
        return base.hash(); 
    }
};

} }

......但是,这并不工作,因为编译器不能告诉大家,enable_if<condition, Derived>::type是Derived.如果我可以更改std::tr1::hash,我只需添加另一个虚拟模板参数boost::enable_if,如enable_if文档所建议的那样,但这显然不是一个很好的解决方案.有没有解决这个问题的方法？我是否必须在每个unordered_set或 …

假设我有一个基类:

class baseClass  
{  
  public:  
baseClass() { };

};

派生类:

class derClass : public baseClass
    {  
      public:  
    derClass() { };

    };

当我创建一个被调用derClass的构造函数的实例时 baseClass.我怎么能阻止这个？

这是一个让我烦恼的代码示例:

class Base {
  protected:
    virtual void foo() = 0;
};

class Derived : public Base {
  private:
    Base *b; /* Initialized by constructor, not shown here
                Intended to store a pointer on an instance of any derived class of Base */

  protected:
    virtual void foo() { /* Some implementation */ };
    virtual void foo2() {
      this->b->foo(); /* Compilator sets an error: 'virtual void Base::foo() is protected' */
    }
};

您如何访问受保护的覆盖功能？

谢谢你的帮助.:O)

鉴于这个人为的例子:

struct point_2d {
  point_2d& x( int n ) {
    x_ = n;
    return *this;
  }

  point_2d& y( int n ) {
    y_ = n;
    return *this;
  }

  int x_, y_;
};

struct point_3d : point_2d {
  point_3d& z( int n ) {
    z_ = n;
    return *this;
  }

  int z_;
};

int main() {
  point_3d p;
  p.x(0).y(0).z(0); // error: "point_2d" has no member named "z"
  return 0;
}

我们的想法是使用"member-function chaining"来连续调用多个成员函数.(有很多例子;上面是我能想到的最短的一个问题.我的实际问题是类似的,如下所述.)

问题是,如果派生类添加了自己的链接成员函数,但是首先调用基类的成员函数,则会得到一个基类引用,当然不能用于调用派生类的成员函数.

有没有聪明的方法来解决这个问题,仍然保持成员函数链的能力？

实际问题

我的实际问题是我的基类是一个异常,我的派生类是从基本异常派生的类.对于那些类,我也想使用成员函数链接:

class base_exception : …

我找到了一些我正在研究的代码,并且想知道最好的设计实现是什么.

如果基类将方法定义为虚拟,但也实现了一个空体,因此不需要派生类实现一个体,那么它是不是应该变为纯粹的呢？

virtual void AMethod1() {}                 // 1
virtual void AMethod2() {assert(false);}   // 2
virtual void AMethod3() = 0;               // 3

1. 目前的代码.
2. Idea1:警告用户此派生对象尚未实现此方法体.
3. Idea2:强制派生类来实现一个体,空或不.

你是一个值得信赖的神奇SO人物,你会怎么想？

编辑1:发布(并阅读答案)后,我意识到断言是坏的!

virtual void AMethod3() = {throw (ENotImplemented)};               // 4

我需要一种方法来创建一个静态类,其中一些常量可以是特定于案例的,但是是硬编码的.

我真正想做的是有一个类,当类扩展时提供了几个常量 - 我希望'常量'是硬编码的.我想我将制作一些抽象属性并定义get {return constant; 当扩展类时.

我知道这是不可能的,所以现在我面临两个选择,我想知道什么是最好的和为什么(如果有我缺少的选项,请告诉我!)

1. 创建一个具有可空字段的静态类,如果在调用静态方法时字段为null,则抛出异常.
2. 放弃静态类.拥有一个带有抽象属性的非静态类,并在我需要的任何地方创建一个对象实例,即使所有功能都是静态的.

我知道这可能是主观的,并且取决于案例,但是当我考虑这个问题时我会绕圈子,并且可以通过一些外部输入来实现.加上我希望可能没有做我想做的事情,而我只是在考虑这个错误.

更新:代码:我将尝试编写一些描述我想要完成的代码.我知道这段代码不行!

想象一下,抽象类Calculation在一个dll中,被许多项目使用.所有这些功能都是相同的,只是常量因项目而异.

public abstract static class Calculation
{
    private abstract int Constant { get; }    //The constant is unknown at this time

    public static int Calculate(int inputValue)
    {
        return inputValue * Constant;
    }
}

Calc类是在一个单独的项目中定义的,其中需要功能并且Constant已知.

public static class Calc : Calculation
{
    private override int Constant { get { return 2; }
}

...

static class Program
{
    [STAThread]
    static void Main()
    {
        //At some point:
        int …

我希望能够在C#基类中有一个方法,可以在几个派生类的对象上调用,返回对象本身,让CLR知道对象的实际类型 - 即适当的派生类型. 有人可以建议一种方法吗？ 其他当然,还有C#没有的返回类型协方差.

像这样的东西,除了Method()返回类型应该是派生类的类型,而不是基类:

public abstract class Base { 
    public Base Method() { return this; }
}

public class Derived1: Base { ... }

public class Derived2: Base { ... }

public class Main {
    public static int Main() {
        Derived1 d1 = new Derived1();
        Derived1 x = d1.Method();
        Derived2 d2 = new Derived2();
        Derived2 y = d2.Method();
    }
}

我只能想到两种方法来完成这项工作,我不喜欢其中任何一种:

1. 将Method()的结果转换为期望的类型(例如,Derived1 x = (Derived) d1.Method();).但是施法者是魔鬼的工具,此外,该方法的目的是返回一个Derived1或Derived2或......,而不是一个Base …

我已经是一名.Net编码员(不能说我是程序员)2年了.有一个问题我多年来都无法理解,那就是基类的实例如何能够保存派生类的实例？

假设我们有两个类:

class BaseClass
{
    public A propertyA;
    public B propertyB;
}

class DerivedClass ?BaseClass
{
    public C propertyC;

}

怎么会发生这种情况:

BaseClass obj = new DerivedClass ()

我的意思是,内存模型BaseClass没有空间用于新添加的propertyC,那么它怎么能保持propertyC的值呢？

另一方面,这怎么可能不会发生:

DerivedClass  obj = new BaseClass()

我认为这是正确的方法,因为内存模型DerivedClass具有BaseClass的所有空间甚至更多.但事实并非如此,为什么呢？

我知道我问的是一个非常愚蠢的问题,但有人可以给我一个更详细的答案吗？从内存或编译器的角度来看会更好.

当你读到这篇文章时,你会非常想提出一些建议,比如"由于以下原因,这是一个坏主意......"

忍受我.我知道还有其他方法可以解决这个问题.这个问题应该被认为是琐事.

假设您有一个"交易"类,它具有所有交易的共同属性,例如发票,采购订单和销售收据.

让我们以交易"金额"的简单示例为例,这是给定交易的最重要的货币金额.

public class Transaction
{
    public double Amount { get; set; }

    public TxnTypeEnum TransactionType { get; set; }
}

此数量可能在派生类型中具有更具体的名称...至少在现实世界中.例如,以下值实际上都是相同的:

• 交易 - 金额
• 发票 - 小计
• PurchaseOrder - 总计
• 销售收据 - 金额

所以现在我想要一个派生类"Invoice",它有一个小计而不是一般命名的Amount.理想情况下,以下两种情况都是正确的:

1. 在Transaction的实例中,Amount属性将是可见的.
2. 在Invoice的实例中,Amount属性将被隐藏,但Subtotal属性将在内部引用它.

发票看起来像这样:

public class Invoice : Transaction
{
    new private double? Amount
    {
        get
        {
            return base.Amount;
        }
        set
        {
            base.Amount = value;
        }
    }

    // This property should hide the generic property "Amount" on Transaction
    public double? SubTotal
    {
        get
        { …

以下构造的实际效果是什么:

class Base { /* ... */ };

template<class T>
class Derived : public T { /* ... */ };

int main() {
    Derived<const Base> d;
    // ...
}

Derived该类是否只能访问const接口的-part Base？我的第一次测试表明实际上根本没有效果.为什么？

谢谢!