小编fee*_*ree的帖子

当我在一个类中设计一个函数时,我想平衡我可以从中提取的信息.某些信息可能对调试很有用,但作为函数的输出不是必需的.我给出以下示例:

class A
{
   bool my_func(int arg1, int &output, std::vector<int> &intermediate_vec);
  {
     // do something
  }
}

在函数中my_func,std::vector<int> &intermediate_vec没有必要,因为我感兴趣的唯一信息存储在变量中output.但是,出于调试目的,我也有兴趣获取,intermediate_vec因为由于某种原因在函数内检查此变量是不方便的.因此,我正在考虑在A类中设计两个函数,一个用于调试,另一个用于实际应用.

    class A
    {
       // for debug
       bool my_func(int arg1, int &output, std::vector<int> &intermediate_vec);
      {
         // do something
      }
      // invoked by other programs 
      bool my_func(int arg1, int &output);
      {
         // do something
        std::vector<int> intermediate_vec
        return my_func(arg1, output, intermediate_vec);
      }
    }

我只是想知道有更好的方法来完成这项工作.谢谢.

假设一条线段有25个点，这些点可能分布不均（空间上），如下图所示：

我的问题是我们如何在这 25 个点中选择 10 个点，以便这 10 个点在空间上尽可能均匀分布。在idea的情况下，选择的点应该是这样的：

编辑： 如果我能说出证明“均匀分布”合理的标准，这个问题确实会变得更加优雅。我所知道的是我对所选点的期望：如果我将线段分成 10 个相等的线段。我希望每个小线段上应该有一个点。当然也有可能在一些小的线段中找不到代表点。在这种情况下，我将求助于具有代表点的相邻小线段。下一步我将把选择的相邻段进一步分成两部分：如果每部分都有代表点，那么空代表点问题就解决了。如果我们在其中一个小线段中找不到代表点，我们可以进一步将其分成更小的部分。或者我们可以求助于下一个相邻的线段。

编辑： 使用动态规划，一个可能的解决方案实现如下：

#include <iostream>
#include <vector>
using namespace std;


struct  Note
{
    int previous_node;
    double cost;

};
typedef struct Note Note;

int main()
{

    double dis[25] = 
    {0.0344460805029088, 0.118997681558377, 0.162611735194631,
    0.186872604554379, 0.223811939491137, 0.276025076998578,
    0.317099480060861, 0.340385726666133, 0.381558457093008,
    0.438744359656398, 0.445586200710900, 0.489764395788231,
    0.498364051982143, 0.585267750979777, 0.646313010111265,
    0.655098003973841, 0.679702676853675, 0.694828622975817,
    0.709364830858073, 0.754686681982361, 0.765516788149002,
    0.795199901137063, 0.823457828327293, 0.950222048838355, 0.959743958516081};

    Note solutions[25];
    for(int i=0; i<25; i++)
    {
        solutions[i].cost = 1000000;
    }
    solutions[0].cost = 0;
    solutions[0].previous_node = …

我的问题非常类似于如何在std :: vector中找到一个项目？但是,我想更进一步,假设我正在搜索的项目在向量中出现了几次,我也希望在向量中获得它的位置.例如,我拥有的矢量是[ 1 3 4 3 7],我要搜索的项目是3.然后项目的位置是1和3.使用该std::find函数,我只能在向量中获得它的第一个位置.有任何想法吗？

内存管理对于图像类至关重要.在opencv中,图像类cv::Mat具有精细的内存管理方案.假设我已经拥有自己的图像类SelfImage:

class SelfImage
{
  public:
    int width_;
    int height_;
    unsigned char *pPixel_;    
};

首先,我将把所有图像像素内容放到这个类中:

SelfImage myImage;
myImage.width_ = 300;
myImage.height_ = 200;
myImage.pPixel_ = new [300*200];
for(int i=0; i<300*200; i++)
      myImage.pPixel_[i] = i%200;

然后我的问题是如何以cv::Mat一种非常有效的方式将这个类转换为一个解决方案,我有一个解决方案:

  cv::Mat mat;
    mat.create( myImage.height_, myImage.width_, CV_8UC1);
    mat.data = myImage.pPixel_;

我不知道这是否是一个很好的解决方案.如果cv::Mat::create函数也会分配内存,那么上面的代码就有内存泄漏的危险.有任何想法吗？

编辑 我必须说清楚,如果我可以使用cv::Mat::create方法但是与类共享内存会很好SelfImage.原因是定义了一个函数来执行图像类转换作业void TransImageType(const SelfImage &geo_img, cv::Mat &mat);

我知道valgrind可以调用memcheck来进行内存泄漏检查，这种情况下编译出来的C++可执行程序必须包含调试信息。那么，如果我想使用 valgrind/callgrind 来执行分析，可执行文件是否必须包含调试信息？我运行了一个小测试，似乎 valgrind/callgrind 可以在没有调试信息的情况下发布可执行程序。有人可以确认吗？

OPENCV中的许多函数都使用InputArray和OutputArray作为函数参数.例如,OPENCV中的Hough变换函数:

void HoughLines(InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0 )

在内部函数中,我们必须使用InputArray函数getMat将其赋予真正的输入数组类型.例如,Mat image= _image.getMat().同样,我们必须使用 copyTo函数将真正的输出数组转换为OutputArray格式.例如,Mat(lines).copyTo(_lines).

我的问题是为什么OPENCV以这种方式设计其功能签名.以霍夫函数为例,如果我们使用以下函数签名:

void HoughLines(Mat &image, std::vector<Vec2f> &lines, double rho, double theta, int threshold, double srn=0, double stn=0 )

我希望它会更好,因为它会消除额外的不必要的复制操作.

我知道我们可以使用\defgroup关键字在 doxygen 中定义一个组，并使用关键字在该组中添加类\addtogroup。我的问题是如何在文档中引用该组。例如，

/**
* \defgroup abc abc
*/

  /**
  * \addtogroup auxiliary_functions
  * @{
  */

 /**
 * Introduction to A. 
 */
 class A
  {

 };
/*
  * @}
*/

那么，在一个page section中，如何引用abc组呢？

/** @page tttt
*   how to refer to group abc?
*
*/

Pyreverse是一个从 Python 代码生成 UML 图的好工具。但是，我发现它无法识别函数中使用的所有类。我用下面的例子来说明我的观点：

class ClassA(object):
   def __init__(self):
         pass
class ClassB(object):
   def __init__(self):
         pass
class ClassC(object):
   def __init__(self):
      self.object_b = ClassB() 
   def perform():
      object_a = ClassA()

如果我们使用pyreverse生成类图，很明显我们可以看到ClassB是 中的一个组件ClassC。ClassA但是，它无法生成其函数 中使用的与 的关系perform。Pyreverse 有什么办法可以检索ClassC和之间的关系ClassA吗？

我的问题是如何使用MATLAB搜索文件夹中的某种类型的文件.我举一个例子详细说明我的问题:

假设我们有以下文件夹及其中的文件:

My_folder
    Sub_folder1
        Sub_sub_folder1
              a.txt
        1.txt
        2.txt
    Sub_folder2
        3.txt
    abc.txt

在这个例子中,我想找到所有.txt文件My_folder及其子文件夹.我想知道我能用MATLAB做些什么.谢谢!

以下示例用于说明我的问题:

#include <iostream>
#include <string>

int main()
{

  signed char p;
  signed char temp=100;
  signed char t=4;
  p = (temp+temp+temp+temp)/t;
  std::cout << "Hello, " << int(p)<< "!\n";
}

在上面的代码中,变量p被定义为四个singed char变量的平均值.但是,signed char变量(temp + temp + temp + temp)的总和将大于signed char的范围.所以我的问题是C++如何处理这种情况.