相关疑难解决方法(0)

我希望有某种std::vector不能超过const int MAX_LENGTH元素的东西.我理解我无法覆盖std::vector非虚函数,我需要做的是对所有相关的成员函数进行大小检查(例如assign,push_back......有这么多).最明显的方法是std::vector用一个class确保不会超出最大长度的操作.但这似乎很笨拙.有没有比封装类更优雅的解决方案来限制std :: vector的大小？

是否可以围绕非矩形图像包装文本？

我希望不同国家的地图周围的文字能够围绕这个国家的形状进行包裹,使得文本总是与国家的边界​​保持相同的距离,即使边界本身不是直的.

这可能吗？

相关内容：为 dicts 格式化 python 文档字符串。

为作为参数传递给函数的字典提供文档的正确方法是什么？这是我编写的样式示例（基于 Sphinx 的 Google 文档样式）：

def class_function_w_dict_argument(self, T_in, c_temps):
    """ This calculates things with temperatures

    Notes:
        All temperatures should be given in Kelvin

    Args:
        T_in (float): Known temperature (K)
        c_temps (dict): Dictionary of component temperatures
            {T1 (float): temperature (K)
             T2 (float): temperature (K)
             T3 (float): temperature (K)
             T4 (float): temperature (K)
             T5 (float): temperature (K)}

    Returns:
        T_out (float): Calculated temperature
    """

所以这是本书的引用:

重写方法不得抛出新的或更广泛的已检查异常,而不是重写方法声明的异常.例如,声明FileNotFoundException的方法不能被声明SQLException,Exception或任何其他非运行时异常的方法覆盖,除非它是FileNotFoundException的子类.

现在这是我的问题,如果超类中的方法抛出异常,那么重写方法是否可以抛出异常呢？

因为我刚刚在Java中尝试了这一点,其中重写方法没有抛出任何异常,并且没有错误.

请解释.

我有一种情况,我需要修改超类方法以获得子类特定的逻辑,但方法逻辑对于所有其他子类是相同的.

我有两个选择:

1)使方法抽象,除了我有关的子类之外,重复相同的代码.

2)覆盖我想要改变逻辑的有关子类中的非抽象方法.

在Java中覆盖非抽象方法是一种很好的做法吗？什么是概念上b/w覆盖非抽象方法和抽象方法的区别.

我有以下课程:

public class Publisher<T> {

    private static final Class[] SUPPORTED_CLASSES = new Class[]{T1.class, T2.class};

    public Publisher() {
        if(Arrays.asList(SUPPORTED_CLASSES).contains(T)) { // error: expression expected!
            System.out.println("Class not supported!");
        }
    }
}

如何检查类参数是否符合实现？
在上面的例子中,我不能使用类参数T作为参数.

我在C#中编写了一系列集合类,每个集合类都实现了类似的自定义接口.是否可以为接口编写单个单元测试集合,并在几个不同的实现上自动运行它们？我想避免每个实现的任何重复的测试代码.

我愿意研究任何框架(NUnit等)或Visual Studio扩展来实现这一目标.

对于那些希望这样做的人,我根据avandeursen公认的解决方案发布了我的具体解决方案作为答案.

我在这里和这里看到了很少有关于这类基本问题的宠物和狗类型的例子,但它们对我来说没有意义,这就是为什么.

假设我们有以下类结构

class Pet {};
class Dog : public Pet {};

然后是以下声明

a (Dog) is a (Pet)

在我的观点中,在现实生活中可能是真的,但在C++中却不是这样.只需看看Dog对象的逻辑表示,它看起来像这样:

更合适的说法

a (Dog) has a (Pet)

要么

a (Pet) is a subset of (Dog)

如果你注意到它与"狗是宠物"的逻辑相反

现在的问题是,#2不允许下面的#1:

Pet* p = new Dog;  // [1] - allowed!
Dog* d = new Pet;  // [2] - not allowed without explicit casting!

我的理解是不[1]应该在没有警告的情况下被允许,因为指针不应该能够指向其超集类型的对象(Dog对象是Pet的超集),因为Pet对新成员一无所知狗可能已经宣布(上图中的狗 - 宠物子集).

[1]相当于int*试图指向一个double对象!

很明显,我错过了一个关键点,这将使我的整个推理颠倒过来.你能告诉我它是什么吗？

我相信与现实世界的例子相似只会使事情复杂化.我希望从技术细节方面理解这一点.谢谢!

假设我想编写一个接收指针的函数.但是我想允许调用者使用裸指针或智能指针 - 无论他们喜欢什么.这应该是好的,因为我的代码应该依赖于指针语义,而不是指针实际实现的方式.这是一种方法:

template<typename MyPtr>
void doSomething(MyPtr p)
{
    //store pointer for later use
    this->var1 = p;

    //do something here
}

上面将使用duck typing并且可以传递裸指针或智能指针.当传递的值是基指针时我们需要查看是否可以转换为派生类型.

template<typename BasePtr, typename DerivedPtr>
void doSomething(BasePtr b)
{
    auto d = dynamic_cast<DerivedPtr>(b);
    if (d) {
        this->var1 = d;

        //do some more things here
    }
}

上面的代码适用于原始指针,但不适用于智能指针,因为我需要使用dynamic_pointer_cast而不是dynamic_cast.

上面问题的一个解决方案是我添加了一个新的实用工具方法,类似于universal_dynamic_cast通过选择使用的重载版本在原始指针和智能指针上工作std::enable_if.

我的问题是,

1. 添加所有这些复杂性是否有价值,因此代码支持原始指针和智能指针？或者我们应该shared_ptr在我们的库公共API中使用？我知道这取决于库的目的,但是使用shared_ptr所有API签名的一般感觉是什么？假设我们只需要支持C++ 11.
2. 为什么STL没有内置指针强制转换,无论你是否传递原始指针或智能指针？这是故意的STL设计师还是只是疏忽？
3. 上述方法中的另一个问题是智能感知的丢失和可读性的缺失.这显然是所有鸭类型代码中的问题.但是,在C++中,我们有一个选择.我可以很容易地在上面强烈地输入我的论点,就像shared_ptr<MyBase>会牺牲灵活性来让调用者传递包含在任何指针中的任何东西,但是我的代码的读者会更自信,并且可以在应该进入的内容上构建更好的模型.在C++公共库API中,是否有这样或那样的一般偏好/优势？
4. 我在其他SO回答中看到了另一种方法,作者提出你应该只使用template<typename T>并让调用者决定T是否是某种指针类型或引用或类.如果我必须在T中调用某些东西,这种超级泛型方法显然不起作用,因为C++需要解除引用指针类型,这意味着我必须创建实用程序方法,例如universal_deref使用std::enable_if将*运算符应用于指针类型但不对普通对象执行任何操作.我想知道是否有任何设计模式可以更容易地实现这种超级通用方法.最重要的是,是否值得去解决所有这些问题,或者只是保持简单并 …

我有以下简化方案：

class NetworkAnalyzer(object):
    def __init__(self):
       print('is _score_funct implemented?')

    @staticmethod
    def _score_funct(network):
        raise NotImplementedError

class LS(NetworkAnalyzer):
    @staticmethod
    def _score_funct(network):
        return network

我正在寻找应该使用什么来print('is _score_funct implemented?')确定子类是否已经实现_score_funct(network)。

注意：如果有一种更Pythonic/传统的方式来构造代码，我也将不胜感激。我这样定义它的原因是，一些 NetworkAnalyzer 子类在其定义中具有 _score_funct ，而那些没有它的子类将具有不同的变量初始化，尽管它们将具有相同的结构