请考虑以下代码：

class Outer
{   
class Inner
{
public:
    Inner(Inner&& i):outers(std::move(i.outers)),test(std::move(test))
    {}

    void addOuter(const Outer& o) {outers.push_back(std::move(o));} 
private:
    std::vector<Outer> outers;      
    std::unique_ptr<std::string> test;      
};

public:
Outer(Outer&& o):inners(std::move(o.inners))
{}
private:
std::vector<Inner> inners;

};

当我尝试在Visual Studio 2012上编译上面的代码时,我收到以下错误：

错误1错误C2248：’std :: unique_ptr< _Ty> :: unique_ptr’：无法访问类’std :: unique_ptr< _Ty>‘中声明的私有成员

显然,编译器调用复制构造函数而不是addOuter方法中的push_back中的移动构造函数.这是编译器错误吗？如果不是为什么,对于这个特定情况,是不是调用了移动构造函数？

因为o作为const引用传递给addOuter.

为什么我不允许使用以下语法在类的构造函数体中调用成员对象/不同类的构造函数？

class Circle {
   double radius;

   public:
          Circle(double r) : radius(r) { }
          double area() {return radius*radius*3.14159265;}
};

class Cylinder {
   Circle base;
   double height;

   public:
          Cylinder(double r,double h)  {
          base(r);
          height = h;
          }
          double volume() {return base.area() * height;}
};

顺便说一下,我知道我可以使用Cylinder(双r,双h)之类的成员初始化列表通过Cylinder(double,double)调用Circle :: Circle(double)：base(r),height(r){}但仍然是什么编译器生成此错误的前一种方法有错吗？

问题是当C开始执行构造函数代码时,必须已经构造了所有成员变量(例如,如果你在构造之前调用Circle的方法怎么办？).

如果立即构造是一个问题,那么可能的解决方案是向您的成员添加默认构造函数和包含类的构造函数体中的using赋值.

你可以想象像int或double这样的本地类型确实有一个默认的构造函数,这就是你以后可以初始化它们的原因(但是请注意,对于该语言的许多丑陋的怪癖之一,int或double的默认构造函数实际上并不是这样的在这种情况下做任何事情并且你不允许对这样的成员做任何事情,除非给它赋值 – 例如,不允许读取它.

您不能在正文中使用base(r),因为它不是有效的语句…在带有左括号的名称之后仅用于函数调用,声明中的初始化或构造函数成员初始化列表中的成员初始化.

如果您为Circle提供默认构造函数,那么您可以这样做

Cylinder(double r,double h) {
    base = Circle(r);
    height = h;
}

但请注意,构建非工作对象以便以后修复它们的方法不是C的最佳方法.该语言喜欢这样的想法：如果一个对象被构造,那么它是可用的,只有在必要时才会考虑与它的偏差(C 11从移动构造函数的原始路径中稍微偏离……但这是另一个故事).

以下代码将构造函数从base转发为派生类.

为什么2个复制构造函数调用？在后台发生了什么？

用g编译.

#include <iostream>
using namespace std;

struct A {
    A() { cout << "A" << endl; }
    A(const A&) { cout << "A(const A&)" << endl; }
    template<typename T> A(T a); // Needed to compile :-O
};

template<typename T>
struct C : public T { using T::T; };

int main()
{
    A a;
    C<A> ca(a);
    //C<A> caa(ca);
    return 0;
}

输出是：

A
A(const A&)
A(const A&)

通过在A中定义构造函数模板,C将被赋予具有类似签名的构造函数模板.它隐含地定义为：

template<typename T>
struct C : public T
{
    //using T::T;

    C() = default;
    C(C const&) = default;

    template<typename U> C(U a) : T( std::forward<U>(a) ) {}
};

这现在调用A的复制构造函数两次：一次用于按值获取参数.第二个调用来自T(std :: forward< U>(a))调用A的copy-ctor.这对我来说是令人惊讶的,因为你期望一个继承的ctor调用基类的确切ctor.它已被继承.但事实并非如此,重载决策不是选择A的ctor模板,而是选择普通复制器A(A const&)(见下文).

有趣的是,它并不关心A中构造函数模板的作用,只需要声明它.这就是为什么在OP中,定义可能会丢失;它也可以删除(这可能是一个缺陷？).

只需在初始化T的重载解析期间选择A的复制器(std :: forward< U>(a)).这是这种情况：参数是类型A的右值,它可以直接绑定到const A&参考,根据A的复制者的要求.由于引用绑定是直接的,没有派生到基本的转换,因此复制者排名为完全匹配. A中的ctor模板也被列为精确匹配,但由于模板和非模板函数在重载集中具有相同的等级,因此非模板函数是首选(复制函数A(A const& ;)).

我是.NET C#和DI的新手. autofac并且在我无法完全控制来电方时遇到问题以了解如何使用DI.

我有两个问题需要理解.

场景1：调用者需要一个默认构造函数(没有任何参数)

当我还想在构造类时注入一些服务接口时,如何处理这种情况？我在考虑构造函数链接,但这意味着我必须知道具体的类型,并且它围绕DI的思想工作. (至少我认为).

public class ServiceWorker
{
    IService _service;

    public ServiceWorker(IService service) 
    { 
        _service = service
    }
}

public class Caller
{
    // No way to change this. 
    var serviceWorker = new ServiceWorker();
}

Scneario 2：Caller期望一个特定的构造函数签名(例如

同样的问题在这里当调用者期望构造函数签名完全匹配时,如何注入其他依赖项？

我认为我理解这个概念的主要问题是,当不是所有的东西都由DI(来电者)构建时,我不会看到如何仅部分地进行DI

public class ServiceWorker
{
    IService _service;

    public ServiceWorker(string name,string id,IService service) 
    { 
        _service = service
    }
}

public class Caller
{
    // No way to change this. 
    var serviceWorker = new ServiceWorker(name,id);
}

我知道,这是非常基本的,但我相信在继续之前我需要首先理解这一点.还有替代品吗？

正如Steven在他的评论中正确指出的那样,仅限于特定的构造函数签名是Constrained Construction反模式的一个实例.但有时,这可能超出您的控制范围.

一个例子是so-called ‘Provider pattern’,which isn’t a pattern at all.在这样的例子中,你可能必须按照第三方框架的规则进行游戏,因此你无能为力.这些框架应被视为对依赖注入不友好.

考虑OP中的场景2,因为场景1只是场景2的特例.如果必须提供具有某个构造函数的类,则可以创建具有所需构造函数签名的Facade.这使您可以避免使用依赖注入的精心设计的类来污染第三方框架强加的约束.它可能看起来像这样：

public class ServiceWorker
{
    IService _service;

    public ServiceWorker(string name,IService service) 
    { 
        _service = service
    }
}

public class ServiceWorkerFacade
{
    ServiceWorker imp;

    public ServiceWorkerFacade(string name,string id) 
    { 
        imp =
            new ServiceWorker(
                name,id,new FooService(
                    new BarService(),new BazService());
    }
}

public class Caller
{
    // No way to change this. 
    var serviceWorker = new ServiceWorkerFacade(name,id);
}

FooService实现了IService.为了让事情变得有趣,我假设FooService有自己的依赖关系,并且BarService和BazService满足了这些依赖关系.

正如Steven建议的那样,你可以(从必要性)考虑Facade的构造函数Composition Root.

如果您有任何机会影响相关框架的设计,您可以将开发人员指向my guidance on designing DI-friendly frameworks.