以父对象作为参数调用子对象的函数：复制两次的原因是什么？

Question

具有以下代码：

#include <iostream>

struct A
{
    int x;
    A(){}
    ~A(){std::cout <<"~A("<<x<<")\n";}
};
struct B: public A
{
};
void f(A a)
{
    a.x = 2;
}

void main()
{
    B b;
    std::cout <<"----------\n";
    b.x = 1;
    f(b);
    b.x = 3;
    std::cout <<"----------\n";
}

在这种情况下，输出如下：

----------
~A(2)
~A(1)
----------
~A(3)

相同的代码，但虚拟函数被添加到父类：

#include <iostream>

struct A
{
    int x;
    A(){}
    ~A(){std::cout <<"~A("<<x<<")\n";}
    virtual void ff() {}
    A(A& ca): x(ca.x){}
};
struct B: public A
{
};
void f(A a)
{
    a.x = 2;
}

void main()
{
    B b;
    std::cout <<"----------\n";
    b.x = 1;
    f(b);
    b.x = 3;
    std::cout <<"----------\n";
}

在这种情况下，我们有以下输出：

----------
~A(2)
----------
~A(3)

编辑：
编译器是：MSVCPP 10

---

问题如下：

1. 为什么我们在第一种情况下有双重复制？
2. 为什么在第二种情况下我们只有一份副本？
3. 第一种情况：为什么编译器不优化第一种情况（通过减少复制操作数量）？

4. 执行以下代码：

   void f(int);
   //...
   双 d；
   f(d);
   

也进行双重复制？

Answer 1

这两种情况在 gcc 4.3.4 上的输出为：

----------
~A(2)
----------
~B
~A(3)

示例 1
示例 2

此输出可以解释为：
当您调用 f(b); 时，会创建 B 类型的对象的副本，因为它是按值传递的。
但是存在对象切片，因为函数参数采用 A 类型的对象。因此，函数中的对象现在属于 A 类型，并且在从函数返回时被销毁，导致调用输出 ~A(2)。

以下两条痕迹来自 main() 中创建的对象 b 的销毁，因为它的类型是 B基类 A 和派生类 B 的析构函数都被调用。

我不确定我是否错过了 gcc 在这种情况下可能执行的任何明显优化，但对我来说，输出看起来几乎符合预期。