标签: polymorphism

以下文件Poly.hs文件

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE RankNTypes #-}
module Poly () where

type ListModifier s = forall a. s -> [a] -> [a]

instance Monoid (ListModifier s) where
  mempty = const id
  mappend f g st = f st . g st

获取要注意的类型检查器:

Poly.hs:8:10: Illegal polymorphic or qualified type: ListModifier s …
    In the instance declaration for ‘Monoid (ListModifier s)’
Compilation failed.

最初我虽然它不能组成2级类型但是:

?> :t (undefined :: forall a . a -> String …

有人可以解释一下,如果我们有一个带有virtual成员函数的抽象类,为什么我们需要在子类中再次声明它？例如,请参见下面的示例

抽象类

.h文件

#ifndef ALGORITHM_H
#define ALGORITHM_H

#include <vector>
#include "Event.h"

using std::vector;

class Algorithm{
protected:
  vector<Event>* dataset;
public:
  Algorithm(vector<Event>& dataset);
  virtual ~Algorithm();

  virtual void run() = 0;
};

#endif

.cpp文件

#include "../include/Algorithm.h"

Algorithm::Algorithm(vector<Event>& dataset):dataset(&dataset){}
Algorithm::~Algorithm(){}

鉴于run声明纯虚函数,通过扩展此类,我的期望是它只需要实现.但是,它仍然需要在类中声明扩展此抽象类.

子类

.h文件

#ifndef SELECT_ALGORITHM_RANDOM_H
#define SELECT_ALGORITHM_RANDOM_H

#include "Algorithm.h"

class SelectAlgorithmRandom : public Algorithm{
public:
  SelectAlgorithmRandom(vector<Event>& dataset);
  ~SelectAlgorithmRandom();

  void run(); // <-- why do I need this here, and doesn't it defy the purpose of me …

我正在尝试学习更多关于多态的知识,我试图让它变得尽可能简单,所以我得到了基类图和2个派生类Rectangle和Circle.

class Figure {
public:
    Figure() { cout << "Creating Figure\n"; }
    virtual ~Figure() { cout << "Destroying Figure\n"; }

    virtual double calculateField() {
            return 0;
    }
};

class Rectangle : public Figure
{
public:
    Rectangle(double m_a) : p_a(m_a) { cout << "Creating Rectangle\n"; }
    ~Rectangle() { cout << "Destroying Rectangle\n"; }

    virtual double calculateField() {
        return p_a*p_a;
    }

private:
    double p_a; 
};

class Circle : public Figure
{
public:
    Circle(double m_r) : p_r(m_r) { cout << "Creating Circle\n"; } …

例如,函数length抽象具体的sequence(Foldable),但不抽象具体的整数类型Int:

length :: Foldable t => t a -> Int

拥有以下类型签名会更有用或更方便吗？

length' :: Foldable t, Integral i => t a -> i

当我尝试将基类转换为派生类时,我收到错误.我想访问我放在组件向量中的派生类.

//基础和派生

class Component
{
public:
    Component();
    virtual ~Component();
private:
};

class Material:public Component{...};

//在主要

int textureID = gameScene.gameObjects[0].getComponent<Material>()->texture;

//游戏对象

#pragma once
#include <vector>
#include "Component.h"

class GameObject:public Component
{
public:
    GameObject();
    GameObject(int otherAssetID);
    ~GameObject();

    int assetID;
    std::vector<Component> components;

    void addComponent(Component otherComponent);
    void deleteComponent(Component otherComponent);

    template <class T>
    T* getComponent() {
        for (int i = 0; i < components.size(); i++)
        {
            if (dynamic_cast<T*>(components[i]) != nullptr)
            {
                T *test = dynamic_cast<T*>(components[i]);
                return test;
            }
        }

        return nullptr;
    }
private:

};

我下面这个教程,试图了解virtual table背后的整个过程pointer和virtual functions in C++.

不确定,当我有这样的代码:

D1 d1;
Base *dPtr = &d1;
dPtr->function1();

为什么我需要所有这些virtual table管理？为什么编译器根本不分配内存地址d1(或基数,如果没有)覆盖virtual function？

我的意思是:如果它需要D1 functon1()地址或Base functon1()地址,它可以在编译时详细说明.它当时知道.为什么以后在运行时看到会浪费时间和资源virtual tables？

我想念这一点.花哨的例子？

在这个StackOverFlow问题之后,让我们说我想扩展到另一个级别的子类,比如Mallards,我该怎么做？

public abstract class Animal <A extends Animal<A>>
{
    public abstract A copyAnimal(A animal);
}

public class Duck extends Animal<Duck>
{
    @Override
    public Duck copyAnimal(Duck duck)
    {
        return copyOfDuck;
    }
}

class Mallard extends Duck<Mallard>
{
    public Mallard copyAnimal(Mallard mallard)
    {
        return copyOfMallard;
    }   
}

一切都适用于Duck子类,但它对于Mallard子类来说是失败的.如何使用未确定数量的子类进行设置？

常量在Haskell中是多态的.所以当我写:

foo = 5

这个去掉了:

foo = fromInteger 5

但是如果添加算术表达式呢？

foo = 42 - 15

究竟是什么会被贬低？

foo = fromInteger (42 - 15)

要么

for = fromInteger 42 - fromInteger 15

另外,观察这个最简单可靠的方法是什么？

在像Clojure这样的动态语言中,很容易表达不同类型的集合:

{:key1 "foo", :key2 [34 "bar" 4.5], "key3" {:key4 "foobar"}}

在Rust中,实现此类集合的首选方法是使用特征对象或枚举.使用Any特征对象似乎是最灵活的方法(如果没有固定数量的已知类型替代方法),因为它允许向下转换为实际的对象类型:

let mut vector: Vec<Box<Any>> = Vec::new();
vector.push(Box::new("I’m"));
vector.push(Box::new(4 as u32));
console!(log, vector[0].downcast_ref::<&str>());
console!(log, vector[1].downcast_ref::<u32>());

这种方法似乎是不鼓励的.它的缺点是什么？

我一直在练习继承,我发现自己在问一个"有一个"关系是什么.

如果我有一个类circleType,我想创建一个类cylinderType,什么派生的区别cylinderType从circleType,只是包括circleType在定义对象成员cylinderType

class cylinderType :
public circleType
{
public:
    cylinderType();
    ~cylinderType();

private:
    double * height;
};

要么:

class cylinderType
{
public:
    cylinderType();
    ~cylinderType();

private:
    circleType baseOfCylinder;
};