小编Rob*_*son的帖子

给定一个抽象接口和从该接口派生的实现,其中构造函数受到保护(这些对象的创建只能从类工厂中获得 - 实现DI模式),如何在工厂函数中使用make_shared？

例如:

class IInterface
{    
public:    
    virtual void Method() = 0;
};

class InterfaceImpl : public IInterface
{
public:
    virtual void Method() {}

protected:    
    InterfaceImpl() {}    
};

std::shared_ptr<IInterface> Create()
{
    std::shared_ptr<IInterface> object = std:: make_shared<InterfaceImpl>();    
    return object;
}

make_shared显然无法访问InterfaceImpl中的受保护构造函数,或者实际上是在IInterface中,给出了以下错误

error C2248: 'InterfaceImpl::InterfaceImpl' : cannot access protected member declared in class 'InterfaceImpl'

所以在这里阅读(问题:如何使boost :: make_shared成为我班级的朋友),我尝试将以下内容放入实现类中:

friend std::shared_ptr<InterfaceImpl> std::make_shared<InterfaceImpl>();

它仍然无法编译.那么我也将另一个放入IInterface类.仍然没有快乐.我在这做错了什么？

编辑:用于编译的完整源文件,与"朋友"...

#include <memory>

class IInterface
{    
public:    
    friend std::shared_ptr&lt;IInterface> Create();     
    virtual void Method() = 0;
};

class …

我正准备实现我自己的类,以便从数组中有效删除,但我想我会问,看看它是否已经存在.我想要的是类似列表的访问效率,但使用数组.我想使用数组是出于缓存一致性的原因,所以我不必一直调用内存分配器(因为在分配节点时使用std :: list).

我想做的是创建一个包含两个数组的类.第一个是一组元素,第二个数组是一组整数,其中每个整数是第一个数组中的空闲槽.因此,我可以非常轻松地从数组中添加/删除元素,而无需为它们分配新内存,只需从空闲列表中获取索引并将其用于新元素即可.

有这样的事情吗？如果我自己做,我还必须自己创建迭代器,所以你可以迭代这个集合,避免数组中的任何空槽,我不太喜欢它.

谢谢.

注意:我想在集合上执行的操作类型是:

1. 迭代
2. 通过索引随机访问单个元素(或者我正在考虑的"句柄")
3. 删除集合中任何位置的元素
4. 在集合中添加元素(顺序不重要)

我设法跟踪到以下表达式的错误:

foo(static_cast<T>(a, b)); // Executes specialisation 1

结束括号错误的地方.正确的陈述应该是:

foo(static_cast<T>(a), b); // Executes specialisation 2

我从来没有见过与形式(a,b)一起使用的static_cast,或者在任何地方看过它.这是什么意思？前一个陈述返回b.

我敢肯定我在这里做了些蠢事,但我看不到它.以下为什么不编译？

#include <algorithm>
#include <memory>
#include <vector>
#include <string>

// A class to play with.  Encapsulates a name.
class StringClass
{
public:
    StringClass(std::string const & name) : MyName(name) 
    {
    }

    std::string const & Name() const
    {
        return MyName;
    }

private:
    std::string MyName;
};

// The set of instances of "StringClass".

std::vector<std::shared_ptr<StringClass>> MyInstances;

// Function returns "true" if a class with the given name exists in the collection.
bool Exists(std::string const & name)
{
    auto i = std::find(MyInstances.begin(), MyInstances.end(), [&](std::shared_ptr<StringClass> const …

作为日志库的一部分,我希望能够迭代参数包,将每个值写入流.然而,我的第一次尝试不能编译.第一个错误是"错误C2144:语法错误:'int'应该以'}'开头".

#include <sstream>
#include <ostream>
#include <iomanip>
#include <fstream>

template <typename ...Args>
std::ostream & Write(std::ostream & o, std::initializer_list<Args...> list) 
{
    size_t size = list.size();

    if(list.size() > 0)
    {
        for(size_t i = 0; i < (size - 1); i++)
            o << list[i] << ", ";

        o << list[i];
    }

    return o;
}

template<typename ...Args>
std::ostream & Write(std::ostream & o, Args...)
{
    return Write(o, { Args... });
}

int main(int argc, wchar_t * argv[])
{
    std::ostringstream o;

    Write(o, 1, "Hello", 2, "World", …

我正在将图像绘制到画布上以在网页上显示。我有该图像的两份副本。第一个是原始的或真实的，第二个是应用了各种图像处理算法的副本。

如何将像素从真实图像复制到副本，以及如何在复制图像后访问副本中的像素来处理图像？

到目前为止我看到的示例都涉及访问和操作画布对象而不是图像数据。这是推荐的解决方案吗？将原始图像绘制到画布上，然后对画布进行处理？

看着这个问题从2010年,在现代OpenGL的有关顶点缓冲区,它仍然是国家直接访问是它们不可用的情况？我已经修改了我的大部分图形库以使用带有帧缓冲,纹理等的DSA但是我仍然需要"绑定"来设置我的顶点数组状态(绑定数组,绑定索引缓冲区,绑定顶点缓冲区,解绑数组等等). ).

更新1: 我无法理解BDL的答案中的参数.我对一个非常简单的顶点缓冲区(一个属性,一个位置)的单元测试给了我一个空白屏幕(它使用描述顶点流的旧方法工作正常).它应该只绘制一个三角形,不需要索引缓冲区.

这就是我正在做的事情,评论是我的理解:

        ::glEnableVertexArrayAttrib(vao,        // VAO name.
                                    0);         // Attribute index (layout in shader).
        ::glVertexArrayVertexBuffer(vao,        // VAO name.
                                    0,          // Binding point.
                                    vbo,        // VBO name.
                                    12,         // Stride (bytes).
                                    0);         // Offset (bytes).
        ::glVertexArrayAttribFormat(vao,        // VAO name.
                                    0,          // Attribute index (layout in shader).
                                    3,          // Component count (x,y,z).
                                    GL_FLOAT,   // Type.
                                    GL_FALSE,   // Normalised.
                                    0);         // Offset (bytes).
        ::glVertexArrayAttribBinding(vao,       // VAO name.
                                     0,         // Attribute index (layout in shader).
                                     0);        // Binding point.

现在,我认为我对绑定点"了解".它们是我可以分配的任意数字,这样我就可以快速轻松地交换不同的属性集.所以在这里使用0进行这个简单的测试就足够了. …

安全取消DownloadFileAsync操作的最佳方法是什么？

我有一个线程(后台工作者)启动下载并管理它的其他方面,当我看到线程已经CancellationPending == true. 开始下载后,线程将停止并旋转,直到下载完成,或者线程被取消.

如果线程被取消,我想取消下载.这样做有标准的习惯用法吗？我试过了CancelAsync,但是我从中获取了一个WebException(中止).我不确定这是一种干净的取消方式.

谢谢.

编辑:第一个异常是和对象在内部流(调用堆栈)上处理一个:

System.dll!System.Net.Sockets.NetworkStream.EndRead(System.IAsyncResult asyncResult)System.dll!System.Net.PooledStream.EndRead(System.IAsyncResult asyncResult)

鉴于以下内容,"功能"是什么类型？

#include <functional>
#include <vector>

template<class T>
class Foo
{
public:

    template<typename P, typename Q, typename R, typename... Args>
    void Attach(P (Q::*f)(Args...), R p)
    {
        auto function = [p, f](Args... args)
        {
            (*p.*f)(args...);
        };

        Listeners.push_back(function);
    }   

private:

    std::vector<std::function<T>> Listeners;
};

class Bar
{
public:

    int Handler(int x, int y, int z)
    {
        return 0;
    }
};

int main(void)
{
    auto foo = Foo<int(int, int, int)>();
    auto bar = Bar();

    foo.Attach(&Bar::Handler, &bar);
}

对于某些上下文,我试图创建一个lambda来调用实例上的方法,将该lambda存储到一个集合中.我的push_back无法编译,出现以下错误:

xrefwrap(283):错误C2440:'return':无法从'void'转换为'int'

我最初使用std :: bind来创建一个我可以存储的std :: function.显然我可以用lambda(和可变参数模板,所以我不需要每个模板一个模板),但到目前为止,它击败了我.

此代码在MSVC(19.00.23918)中编译,但GCC不喜欢它,除非我在调用Detach_Internal()时使用this-> access to member operator.

GCC是否抓住了MSVC不存在的潜在错误？作为一般规则,在引用基类中的函数时始终使用this->更好吗？

注意GCC将使用-fpermissive编译它.

#include <memory>

namespace Events
{
    template<typename T>
    class EventBase
    {
    protected:

        void Detach_Internal(std::weak_ptr<void> const & p)
        {

        }
    };

    template<typename T>
    class Event : public EventBase<T>
    {
    public:

        void Detach(std::weak_ptr<void> const & p)
        {
            Detach_Internal(p);
        }
    };
}


int main(void)
{
    auto event = std::make_unique<Events::Event<void()>>();    
}

33:30:错误:'Detach_Internal'没有依赖于模板参数的参数,因此'Detach_Internal'的声明必须可用[-fpermissive]