标签: dynamic-binding

我最初担心发布这个问题以免重复。但即使在谷歌搜索了许多关键字后，我也找不到任何解释 C 的静态和动态绑定的 StackOverflow 链接。虽然有 C++ 的问题和答案，但是所有涉及的classes东西显然不适合 C。StackExchange 之外的链接非常可疑。

我需要知道这两个绑定之间的严格定义和对比，仅在 CI 的上下文中，如果您能花一些时间来回答它，或者给我 StackOverflow 上的链接，以免我弄错并已得到解答，我将不胜感激之前详细说。

我打算清楚地了解：

1. 在 C 中绑定。
2. C 中的静态与动态绑定。

编辑如果您能用一些简单的代码片段来解释差异，那将非常有帮助。

我正在阅读Peter Norvig的AI范式.在第6.2章中,作者使用如下代码(不是原始代码,我选择了令人不安的部分):

代码片段:

(progv '(op arg) '(1+ 1)
(eval '(op arg)))

作为作者的原始意图,这段代码应该返回2,但是sbcl 1.1.1,在解释器显然没有在环境中查找操作,抛弃op: undefined function.

这个实现是否具体？由于代码必须已在其他一些lisp上进行过测试.

ps 原始代码

我只是在我的Common Lisp代码遇到异常情况时，我想测试locally和declare：

(defvar test-out 2) ;; make a dynamic variable

;; function below just simply re-write from locally doc
(defun test (out)
  (declare (special out))
  (let ((out 1))
    (print out) ;; => 1
    (print (locally (declare (special out)) out)))) ;; => 2

;; when argument has same name as outside dynamic variable
(defun test1 (test-out)
  (declare (special test-out))
  (let ((test-out 1))
    (print test-out) ;; => 1
    (print (locally (declare (special test-out)) test-out)))) ;; => also 1 …

我有以下问题:

我的程序应该在运行时决定加载一个函数(在本例中是GetExtendedTcpTable()),因为该方法在Windows 2000中不可用!(无法仅在Windows 2000中启动软件)

谢谢您的帮助!

招呼leon22

class A
{
  static function get_name_derived_class()
  {
      //This function must return the name of the real class
      //Is it possible without insert a methon in B class?
  {
}

class B extends A
{

}

B::test()

我希望在基类中有一个静态方法,它返回真实(派生)类的名称,而不插入特定的方法.可能吗？感谢名单

当我在Martin Odersky的Scala编程中尝试抽象类型的Animal/Food示例时,

class Food
abstract class Animal {
  type SuitableFood <: Food
  def eat(food:SuitableFood)
}
class Grass extends Food
class Cow extends Animal {
  type SuitableFood=Grass
  override def eat(food:SuitableFood) {}
}
val bessy:Animal = new Cow
bessy.eat(new Grass)

我收到以下错误:

scala> <console>:13: error: type mismatch;
 found   : Grass
 required: bessy.SuitableFood
                  bessy.eat(new Grass)
                            ^

马丁的原始例子bessy.eat(new Fish)肯定会失败,但我没想到它也会失败Grass.可以通过让被避免上述错误bessy是Cow代替Animal:val bessy:Cow = new Cow.

这是否意味着动态绑定在这里不起作用？

编辑: Scala中常规继承的简单动态绑定:

abstract class Parent {
  def …

根据我的理解,C专家Objective-C是一种动态绑定语言,不允许重载类中的任何方法.

但是,如果我编写两个具有相同名称但不同数量的参数列表的方法,有一件事让我恼火:

 // Which is not allowed in objective-c

 -(void)updateValue:(int)intVal{

  } 

 -(void)updateValue:(float)floatVal{

  }

但Objective-C允许的第二种情况是:

 // Allowed in Objective-C

 -(void)updateValue:(int)intVal{

   }

 -(void)updateValue:(float)floatVal :(int)intVal{

   }

虽然两种情况都是方法重载.

现在我的问题是为什么允许第二种情况.

在第二种情况下使用两个参数的方法是否更改了方法名称？或者是其他东西 ？

请解释一下.

假设我们有一个提供课程的图书馆

struct Base { int foo() { return 42; } };

我不能改变那个班级。 99％的人从不愿意重写foo，因此图书馆设计者并未将其虚拟化。但是我需要重写它：

struct MyClass : Base { int foo() { return 73; } };

更糟糕的是，该库具有接受指向的指针的接口Base。我想插入MyClass，但是当然，由于foo它不是虚拟的，因此接口背后的代码始终会调用Base::foo。我要它打电话MyClass::foo。

我该怎么办？有没有使Base::foo虚拟的常见模式？

_{实际上Base::foo是QAbstractProxyModel::sourceModel。我正在实现ProxyChain，将许多代理模型抽象为一个代理模型。 QAbstractProxyModel::setSourceModel是虚拟的，但QAbstractProxyModel::sourceModel不是虚拟的，这会带来很多麻烦。}

void ProxyChain::setSourceModel(QAbstractItemModel* source_model)
{
  for (auto* proxy : m_proxies) {
    proxy->setSourceModel(source_model);
    source_model = proxy;
  }
  QIdentityProxyModel::setSourceModel(source_model);
}

QAbstractItemModel* ProxyChain::sourceModel() const
{
  return m_proxies.front()->sourceModel();
}

根据Apple的Objective C指南,具有相同名称的方法都使用相同的选择器,并且它们需要具有相同的返回类型和参数.

然后有一些关于"静态类型"方法的例外.

那么具有相同名称和返回类型+参数的方法共享一个选择器,但如果它只是相同的名称但不同的返回类型和/或参数,它将有一个不同的选择器 - 如果你发送了这样的消息它...好吧我不知道.

我有一个实现两个接口的抽象类.我正确的思考因为我使用两个接口,我不能使用任何一个接口来实现动态绑定？原因是,如果我使用的接口之一,我显然不能够与其他接口类型系统将只允许子类型调用由我来宣布的多态变量的接口中定义的方法调用的方法呢？

因此,我的实际问题是,我只是真的使用接口来确保我的抽象类(或子类)明确提供方法的实现吗？这似乎与第19条规定的内容相矛盾 - 你应该只使用类型的接口(我认为这意味着多态).

例:

public interface A{
    public void meth1();
}

public interface B{
    public void meth2();
}

public abstract class C implements A,B{

}

public void DynamicBinding(A aobject){
  //Can only call aobject.meth1();
}

我在虚函数中遇到问题:以下是一些代码示例:

class A
   {
      public : virtual  void print(void)
           {
              cout<< "A::print()"<<endl;
           }
    };
 class B : public A
    {
      public : virtual void print(void)
           {
               cout<<"B::print()"<<endl;
           }
    };
 class C : public A
    {
      public : void print(void)
            {
               cout<<"C::print()"<<endl;
            }
     };
  int main(void)
     {
         A a,*pa,*pb,*pc;
         B b;
         C c;
         pa=&a;
         pb=&b;
         pc=&c;

         pa->print();
         pb->print();
         pc->print();

         a=b;
         a.print();
         return 0;
       }

结果:A :: print()B :: print()C :: print()A :: print()

我知道它是一个多态,并且知道有一个名为virtual-function-table的表,但我不知道它是如何实现的,并且

   a=b;
   a.print();

结果是:A :: print()不是B :: print(),为什么它没有多态性.谢谢!

我需要对C++中的动态绑定做一些澄清.
我解释我的问题.
我必须使用二叉搜索树来实现字典.我决定也实现一个AVL树(自我二元搜索树).我已成功实现了两个类:BST(二叉搜索树)和扩展BST的AVL.我的程序工作正常.
我的目标是只有一个指针,我可以从BST类切换到类AVL,向用户询问"你想使用哪种结构？" 在计划开始时.
其余代码是相同的,因为BST和AVL具有相同的方法名称(即使它们执行不同的操作 - >覆盖).
我通过这种方式达到了我的目标:

cout << "whitch structure would you like to use? [1] for BST, [2] for AVL"; 
short choise;  
cin >> choise;

BST a;  
AVL b;  
BST* dictionary;

if (choise == 1)
    dictionary = &a;  
else if (choise == 2)
    dictionary = &b;    
.  
.  
.  
dictionary->doSomething();

我的问题是:
这是一个正确的方法吗？这是动态绑定的一个例子吗？

感谢您的关注,如果我没有正确解释我的问题,我很抱歉,这是我在这个精彩网站上的第一篇文章!

我很难理解一些具有更多经验的人可能理解的代码的工作原理:

(let ((x 0))
  (loop for var in '(x)
    do (set var 3))
  x)

我的期望是表达式应该返回3,x的新值,但它实际上返回0.为什么x没有被重置？是否有另一种方法来迭代变量列表并为它们赋值？