小编Ben*_*Ben的帖子

这是我想要向异常添加一些信息时经常做的一个例子:

std::stringstream errMsg;
errMsg << "Could not load config file '" << configfile << "'";
throw std::exception(errMsg.str().c_str());

有没有更好的方法呢？

OpenCV说的就像

Corrupt JPEG data: premature end of data segment

要么

Corrupt JPEG data: bad Huffman code

要么

Corrupt JPEG data: 22 extraneous bytes before marker 0xd9

使用imread()加载损坏的jpeg图像时.我可以以某种方式抓住它吗？为什么我会收到这些信息？我是否必须自己检查二进制文件？

我正在尝试将查询结果存储在临时表中以供进一步处理.

create temporary table tmpTest
(
    a FLOAT,
    b FLOAT,
    c FLOAT
)
engine = memory;

insert into tmpTest
(
    select a,b,c from someTable
    where ...
);

但由于某种原因,插入需要一分钟,而单独的子选择只需要几秒钟.为什么将数据写入临时表而不是将其打印到我的SQL管理工具的输出需要这么长时间？

更新 我的设置:MySQL 7.3.2集群,带有8个Debian Linux ndb数据节点1个SQL节点(Windows Server 2012)

我正在运行select on的表是一个ndb表.

我试图找出,如果执行计划在使用'insert into ..'时会有所不同,但它们看起来一样:(抱歉格式化,stackoverflow没有表格)

id  select_type     table       type    possible_keys   key     key_len ref                 rows        Extra
1   PRIMARY         <subquery3> ALL     \N              \N      \N      \N                  \N          \N
1   PRIMARY         foo         ref     PRIMARY         PRIMARY 3       <subquery3>.fooId   9747434     Using where
2   SUBQUERY        someTable   range   PRIMARY         PRIMARY 3       \N                  136933000 …

我正在尝试将VS2012中编写的项目迁移到VS2013.

我成功编译了boost 1.53.0(我首先尝试了1.54.0,但得到了一些编译器错误)并得到了类似的库 libboost_filesystem-vc120-mt-1_53.lib.

但是在尝试构建我的项目时,链接器抱怨:

error LNK1104: cannot open file 'libboost_filesystem-vc110-mt-1_53.lib'

我一直在寻找一些项目设置在我的整个解决方案中找出,为什么它试图加载旧的库版本,但我没有找到任何东西.

链接器如何知道要使用哪个库？我该如何解决我的问题？

我写了一个非常简单的文件管理数据库,基本上看起来像这样:

class FileDB
{
public:
    FileDB(std::string dir) : rootDir(dir) { }

    void loadFile(std::string filename, File &file) const;
    void saveFile(std::string filename, const File &file) const;

private:
    std::string rootDir;
}

现在我想迭代遍历数据库中包含的所有文件,例如使用std::iterator:

void iterateFiles()
{
    FileDB filedb("C:\\MyFiles");

    for (FileDB::iterator file_it = filedb.begin(); file_it != filedb.end(); ++file_it)
    {
        File f = *file_it;
        // do something with file
    }
}

我已经阅读了类似问题的答案,有些人建议推导std::iterator,有些人要使用std::iterator_traits,但我真的不明白该怎么做.尝试实现自定义迭代器时可能出现什么问题？什么是简单而优雅的方式呢？

编辑: 请不要考虑使用提升,我的问题更具概念性.

编辑2:

FileDB的工作方式如下:

• ROOTDIR

  • foo1
    • BAR1
      • foo1bar1_1.txt
      • foo1bar1_2.txt
    • BAR2
      • foo1bar2_1.txt
      • foo1bar2_2.txt

  • foo2的

  • 欢

    • barM中

      • fooNBarM_x.txt

所以基本上,我可以通过它的名字找到一个文件.

由于我的容器不在内存中,因此我没有指向其数据的指针.所以我的想法是将文件的路径存储在迭代器中.这样,我可以 …

用C++编写没有memleak的代码对我来说不是问题,我只是坚持RAII习语.

在C#中编写无memleak的代码也不是很难,垃圾收集器会处理它.

不幸的是,编写C++/CLI代码对我来说是一个问题.我以为我已经理解它是如何工作的,但我仍然有很大的问题,我希望你能给我一些提示.

这就是我所拥有的:

用C#编写的Windows服务,内部使用C++库(例如OpenCV).使用C++/CLI包装类访问C++类.例如,我有一个图像对象的MatW C++/CLI包装类cv::Mat,它作为构造函数参数a System::Drawing::Bitmap:

public ref class MatW
{
public:
    MatW(System::Drawing::Bitmap ^bmpimg)
    {
        cv::Size imgsize(bmpimg->Width, bmpimg->Height);
        nativeMat = new Mat(imgsize, CV_8UC3);

        // code to copy data from Bitmap to Mat
        // ...
    }

    ~MatW()
    {
        delete nativeMat;
    }

    cv::Mat* ptr() { return nativeMat; }

private:
    cv::Mat *nativeMat;
};

例如,另一个C++类可能是

class PeopleDetector
{
public:
    void detect(const cv::Mat &img, std::vector<std::string> &people);
}

它的包装类:

public ref class PeopleDetectorW
{
public:
    PeopleDetectorW() { …

我有多个队列正在被多个线程访问.为了实现线程安全,我做了以下事情:

private static Dictionary<string, Queue<string>> MyQueues = new Dictionary<string, Queue<string>>();

public static string GetNextQueueElementForKey(string key)
{
    string res = string.Empty;

    if (MyQueues.Keys.Contains(key))
    { 
       Queue<string> queue = MyQueues[key];
       lock (queue)
       {
           if (queue.Count() > 0)
           {
               res = queue.Dequeue();
           }
       }
   }

   return res;
}

我也可以锁定MyQueues,但是我会锁定不必要的东西.所以我的问题是,如果锁定字典中包含的对象将起作用 - 假设一个键的值(队列)永远不会改变.

假设我有一个指向某个基类的指针,我想创建一个这个对象的派生类的新实例.我怎样才能做到这一点？

class Base
{
    // virtual
};

class Derived : Base
{
    // ...
};


void someFunction(Base *b)
{
    Base *newInstance = new Derived(); // but here I don't know how I can get the Derived class type from *b
}

void test()
{
    Derived *d = new Derived();
    someFunction(d);
}

假设,我有一个非常大的std::map< unsigned int, Foo > FooDB,它将Foo对象保存在内存中,可以通过它们的ID检索.现在可能有更多的Foo对象,而不是可用于存储它们的内存.所以我想要以下结构:

• 检索Foo对象,具有ID X从FooDB
• 如果对象x在FooDB,则返回它
• 如果不是,请从HD加载,尝试将其存储以FooDB供进一步查询
  • 有足够的可用内存:添加到 FooDB
  • 内存不足:通过FooDB从未使用的对象中删除一些空间(最早的查询时间戳)

我想保留一些内存FooDB,我不知道,Foo它可以存储多少个对象,因为它们的大小不同.

有关如何实现这一点的任何想法？

编辑

我的基本问题是:如何判断std::map内存中的大小？当然,包括存储在其中的所有堆对象.如何知道何时没有达到足够的内存部分？

我想用C++创建Foo的非托管数组Foo结构在C#中创建对象.这是我认为它应该工作的方式:

在C++方面:

extern "C" __declspec(dllexport) void* createFooDetector()
{
    return new FooDetector();
}

extern "C" __declspec(dllexport) void releaseFooDetector(void* fooDetector)
{
    FooDetector *fd = (FooDetector*)fooDetector;
    delete fd;
}

extern "C" __declspec(dllexport) int detectFoo(void* fooDetector, Foo **detectedFoos)
{
    FooDetector *fd = (FooDetector*)fooDetector;
    vector<Foo> foos;
    fd->detect(foos);

    int numDetectedFoos = foos.size();
    Foo *fooArr = new Foo[numDetectedFoos];
    for (int i=0; i<numDetectedFoos; ++i)
    {
        fooArr[i] = foos[i];
    }

    detectedFoos = &fooArr;

    return numDetectedFoos;
}

extern "C" __declspec(dllexport) void releaseFooObjects(Foo* fooObjects)
{
    delete [] …

在我所知的大多数语言中，标量类型变量如果未在代码中初始化，则默认情况下会被零初始化。为什么在c / c ++中不会发生这种情况？我能想到的唯一原因是性能，但是

• 如果我初始化它，确实会消耗性能吗？
• 有未定义的行为是否更可取？
• 如果我想避免未定义的行为，则无论如何都必须对其进行初始化，那么我赢了什么？

如果这可能是性能问题，显式地告诉编译器不对变量进行零初始化会不会更容易？

最后一个我的问题：是否有一个gcc选项告诉编译器默认为零初始化？

我正在尝试通过以毫秒为单位测量实际经过时间与以毫秒为单位的cpu时间来在c ++中执行一些性能度量。这是我的代码的样子：

auto start = std::chrono::high_resolution_clock::now();
unsigned begin = clock();

// some computationally expensive task

auto finish = std::chrono::high_resolution_clock::now();
unsigned end = clock();

(finish - start).count();

int duration = std::chrono::duration_cast<std::chrono::milliseconds>(finish - start).count();
int cpu_duration = 1000*(end - begin)/(CLOCKS_PER_SEC);

现在，我希望cpu时间值低于系统时间，因为线程可能会中断。但是，CPU时间是实时时间的2-3倍。我做错了什么还是我误解了CPU时间的概念？

将大向量的所有值重置为其默认值的最快方法是什么？

struct foo
{
  int id;
  float score;
};

std::vector<foo> large_vector(10000000);

最简单的方法是创建一个新的向量，但是我想重新分配内存要比重新初始化一个现有的向量花费更多的时间？

在重置之前，我必须遍历向量以收集非零分数（可能是数千或数百万）。我应该在此循环中逐个重置结构吗？

编辑：

向量大小是固定的，对于每个结构成员（所有浮点数和整数），“默认值”表示0。