小编Sam*_*Sam的帖子

我想将该make_shared<T>函数与派生类一起使用,如下所示

class Base {
     public:
     typedef std::shared_ptr<Base> Ptr;
};

class Derived : public Base {};

Base::Ptr myPtr = std::make_shared(/* Derived() */ );

如何告诉make_shared构建这样的对象？

我想避免经典

Base::Ptr ptr = Base::Ptr(new Derived());

在make_shared函数中使用单个alloc.

我有这段代码(由我的现实生活中的麻烦设计)

它无法编译,抱怨ExtendsB没有实现B::Run(A* a).但是,理解扩展名没有问题A* Run();

class A { };

class ExtendsA : public A { };

class B
{
public:
    virtual ~B(){}  
    virtual void Run(A* a) = 0;
    virtual A* Run() = 0;
};

class ExtendsB : public B
{
public:
    virtual ~ExtendsB(){}

    // Not OK! It does not see it as an implementation of 
    // virtual void Run(A* a) = 0;
    virtual void Run(ExtendsA* ea) {}; 
    virtual ExtendsA* Run() { return new ExtendsA(); }; // OK
}; …

我有一些cpp文件需要很多编译.它们包含一些基本的类/代码,带有一些模板,但没有什么可以证明编译时间大约几十秒.

我确实使用了几个外部库(boost/opencv)

这就是gcc所说的编译时间.如何找到可怕的编译时间的库/包含/函数调用？

Execution times (seconds)
 phase setup             :   0.00 ( 0%) usr   0.00 ( 0%) sys   0.01 ( 0%) wall    1445 kB ( 0%) ggc
 phase parsing           :   6.69 (46%) usr   1.61 (60%) sys  12.14 (47%) wall  488430 kB (66%) ggc
 phase lang. deferred    :   1.59 (11%) usr   0.36 (13%) sys   3.83 (15%) wall   92964 kB (13%) ggc
 phase opt and generate  :   6.25 (43%) usr   0.72 (27%) sys  10.09 (39%) wall  152799 kB (21%) ggc
 |name lookup            : …

我在这里听到很多人说C++ 在所有方面都比C 快或快,但更清洁,更好.

虽然我并不反对C++非常优雅且非常快的事实,但我没有找到关键内存访问或处理器绑定应用程序的替代品.

问题:在性能方面,C风格的数组在C++中是否有等价的？

以下示例是设计的,但我对现实问题的解决方案感兴趣:我开发了图像处理应用程序,并且像素处理的数量巨大.

double t;

// C++ 
std::vector<int> v;
v.resize(1000000,1);
int i, j, count = 0, size = v.size();

t = (double)getTickCount();

for(j=0;j<1000;j++)
{
    count = 0;
    for(i=0;i<size;i++)
         count += v[i];     
}

t = ((double)getTickCount() - t)/getTickFrequency();
std::cout << "(C++) For loop time [s]: " << t/1.0 << std::endl;
std::cout << count << std::endl;

// C-style

#define ARR_SIZE 1000000

int* arr = (int*)malloc( ARR_SIZE * sizeof(int) );

int ci, cj, ccount = 0, csize …

我运行这段代码

#define BOOST_TEST_MAIN
#define BOOST_TEST_DYN_LINK

#include <boost/test/unit_test.hpp>
#include <boost/test/unit_test_log.hpp>
#include <boost/filesystem/fstream.hpp>

#include <iostream>

using namespace boost::unit_test;
using namespace std;


void TestFoo()
{
    BOOST_CHECK(0==0);
}

test_suite* init_unit_test_suite( int argc, char* argv[] )
{
    std::cout << "Enter init_unit_test_suite" << endl;
    boost::unit_test::test_suite* master_test_suite = 
                        BOOST_TEST_SUITE( "MasterTestSuite" );
    master_test_suite->add(BOOST_TEST_CASE(&TestFoo));
    return master_test_suite;

}

但在运行时它说

测试设置错误:测试树为空

为什么不运行init_unit_test_suite函数？

我想在主线程上初始化一些静态数据.

int32_t GetFoo(ptime t)
{
   static HugeBarData data;
   return data.Baz(t);
}

int main()
{
    GetFoo(); // Avoid data race on static field. 
              // But will it be optimized away as unnecessary?

    // Spawn threads. Call 'GetFoo' on the threads.
}

如果编制者可能决定删除它,我怎么能强迫它留在那里？

函数指针可以指向自由函数,函数对象,成员函数调用的包装器中的任何内容.

但是,std :: bind创建的仿函数可以有状态,也可以是自定义创建的.分配该状态的位置,以及删除该状态的人员？

考虑下面的例子 - 删除向量时是否删除状态(数字10)？谁知道在函子上调用一个删除器,而函数指针上没有删除器？

#include <iostream>
#include <functional>
#include <vector>
using namespace std;
using namespace std::placeholders;
class Bar
{
    public:
    void bar(int x, int y) { cout << "bar" << endl; }
};
void foo(int baz){ cout << "foo" << endl; }
int main() {
    typedef std::function<void(int)> Func;

    std::vector<Func> funcs;
    funcs.push_back(&foo); // foo does not have to be deleted
    Bar b;
    // the on-the-fly functor created by bind has to be deleted
    funcs.push_back(std::bind(&Bar::bar, &b, 10, _1)); 

    // …

在新C++11标准中,许多原子操作在"强/弱"对中定义:

template< class T >
bool atomic_compare_exchange_weak( std::atomic<T>* obj, 
                                   T* expected, T desired );
template< class T >
bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, 
                                   T* expected, T desired );

我知道弱者可能会更快,但偶尔会失败,所以需要将它放入while如下的循环中(取自cppreference):

void append(list* s, node* n)
{
    node* head;
    do {
        head = s->head;
        n->next = head;
    } while(! std::atomic_compare_exchange_weak(s->head, head, n));
}

但

1. 弱行动到底是做什么的？为什么他们有时会失败,为什么他们会更快？(我会喜欢一些核心微处理器架构细节.)

2. 什么时候弱的形式更好,什么时候推荐强者？

我有许多必须实时处理视频流的模块.简单的方法是使用帧缓冲区,模块从中获取视频图像,处理,然后删除它们.

问题#1:并非所有模块都以相同的速度工作.有些能够处理所有帧,有些则不能.因此,某些模块不会处理所有帧.如果我在删除缓冲区之前等待所有模块完成作业,那么较快的模块将无理由地停止(图A).

一个简单的解决方案将是图B.每个模块的单独缓冲区.如果缓冲区已满,则不会放置帧.但问题#2出现了:内存被浪费:有些帧在不同的缓冲区中会有多个副本.

更智能的解决方案是一个物理缓冲区,附加更多逻辑缓冲区,如图C所示.当至少一个逻辑缓冲区可以容纳它时,在真实缓冲区中添加一个帧,并且当删除链接到它的所有逻辑缓冲区时删除实际缓冲区.(一个简单的实现解决方案由智能指针给出 - 向缓冲区添加一个智能指针到可以容纳它的所有逻辑缓冲区)问题3:在最坏的情况下,可能会发生每个帧被分配给一个模块,而不是共享,它将是解决方案B的一个混乱的缺点.

题

有没有更好的方法来处理这个问题？标准答案？实现它的模板库？

编辑 这种使用缓冲区的机制很复杂,但如果缓冲区已满,则删除帧,在不同平台上提供可扩展的解决方案:无论模块或硬件性能如何,我都会处理尽可能多的帧.

给定一个vector<Object>,在那里对象有一个功能run(),有没有办法来调用run()的for_each,只使用STD功能/模板？

注意,这run()不是一个静态函数,它实际上应该转换被引用的对象(当然,在我的小例子中并非如此)

我知道的boost::lambda方式

class Object
{
public:
    int run(){/* change object state */}
};

vector<Object> v(10);
for_each(v.begin(), v.end(), bind(&Object::run, _1));

但我很好奇它是否是一种标准(非Cxx11)方式.