小编Tom*_*Tom的帖子

在c ++中的类中包装算法时,我经常遇到const正确性的问题.我觉得我想要一个可变功能,虽然这是不允许的.任何人都可以建议我如何实现如下的类？

以下是我要编写的代码.

• 函数run()不应该是const函数,因为它会更改数据.
• 函数get_result()应该是一个常量函数(就用户而言),因为它返回数据.

但是,如果用户在不调用run()的情况下请求结果,我希望get_result()函数运行算法.这打破了const的正确性,因为我有一个const函数调用非const函数.

class operate_on_data
{
  std::vector<double> m_data;  // the data to modify
  bool m_completed;  // check to see if the function run() has been called
public:
  operate_on_data(std::vector<double> data)
    : m_data(data), m_completed(false) {}  //initialise
  void run() //I don't want this function to be const  
  {
    //The algorithm goes here - it alters m_data.
    m_completed = true;  //the algorithm has been run
  }
  std::vector<double> get_result() const //I want this function to be const
  {
    /*The following …

我是新手cmake,我正在尝试.hpp在保留目录结构的同时安装文件.

到目前为止我有

FILE(GLOB files "${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp"
  "${CMAKE_CURRENT_SOURCE_DIR}/include/MyLib/*.hpp"
  "${CMAKE_CURRENT_SOURCE_DIR}/include/MyLib/detail/*.hpp"

install (FILES ${files}  DESTINATION include)

找到所有文件但目标层次结构已展平.

FWIW bjam我试图模仿的命令是

install headers 
    : ../include/EnsembleLearning.hpp  
      [ glob ../include/MyLib/*.hpp ]  
      [ glob ../include/MyLib/detail/*.hpp ]  
    : <install-source-root>../include ;

该升压元组的文件说:

当前版本支持具有0-10个元素的元组.如有必要,可以将上限增加到例如几十个元素.

但是,我无法找到它说明如何做到这一点.

我希望元组有BOOST_MPL_LIMIT_VECTOR_SIZE元素(默认为20).这是因为我在mpl::vectors和之间进行映射,boost::tuples并且希望所有容器具有相同数量的元素.

我见过生产代码如

::std::vector<myclass> myvec;

我不知道前置的::意思是什么- 为什么用它？

有关示例,请参阅:

C++:迭代STL容器的正确方法

我正在努力学习static_cast和reinterpret_cast.

如果我是正确的,标准(9.2.18)说reinterpret_castpod数据是安全的:

指向POD结构对象的指针(适当地使用a转换) reinterpret_cast指向其初始成员(或者如果该成员是位字段,则指向它所驻留的单元),反之亦然.[注意:因此,在POD-struct对象中可能存在未命名的填充,但不是在其开头,以实现适当的对齐. - 结束说明]

我的问题是如何严格解释这一点.例如,布局兼容性足够吗？如果没有,为什么不呢？

对我来说,以下示例显示了严格的"仅POD有效"解释似乎是错误的示例.

class complex_base  // a POD-class (I believe)
{
public:  
  double m_data[2];
};

class complex : public complex_base
{  //Not a POD-class (due to constructor and inheritance)
public:
  complex(const double real, const double imag); 
}

double* d = new double[4];
//I believe the following are valid because complex_base is POD
complex_base& cb1 = reinterpret_cast<complex_base&>(d[0]);  
complex_base& cb2 = reinterpret_cast<complex_base&>(d[2]);
//Does the following complete a valid cast …

我不明白为什么这不编译:

struct  A
{};  

template<class T> 
struct  B
{};  

template<template<class> class T1, class T2> 
struct C
{};

int
main  (int ac, char **av)
{
  typedef B<double> b;              //compiles
  typedef B<const double> b_const;  //compiles
  typedef B<A> ba;                  //compiles
  typedef B<const A> ba_const;      //compiles

  typedef C<B,double> c1;           //compiles
  typedef C<B,const double> c2;     //compiles
  typedef C<const B,double> c3;     //ISO C++ forbids declaration of ‘type name’ with no type
}

(我发现标准的参考有点神秘)

我需要更改什么才能编译？

编辑:

编译器细节(似乎是相关的):

Using built-in specs.
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu/Linaro …

我试图用这样的boost-units制作一个带尺寸的矢量类,

//vector will be constructed vec<si::length> v(10, 1.0*si::metre);
template<typename dimension>
class vec
{
  public:
  //constructor setting all values to q.
  vec(const size_t, const boost::units::quantity<dimension> q)
  //etc
}

这一切工作正常,除了operator*=和operator/=那些元素方式乘法和除法.由于这些不会改变维度,因此只有在乘以/除以无量纲数量时才有意义:我正在努力寻找未锁定到特定系统的任意无量纲数量(例如si或cgs单位).

我想要的东西,

  /** Multiply a dimensionless vector. */
  vec<dimension>& 
  operator*=(const vec<boost::units::dimensionless_type>& b);

或许是一些元编程魔术(我注意到boost :: units :: is_dimensionless存在,但我不知道如何使用它,因为我不熟悉一般的元编程技术)

  template<typename dimension>
  template<typename a_dimensionless_type>
  vec<dimension>& 
  vec<dimension>::operator*=(const vec<a_dimensionless_type>& b){
    //some compile time check to make sure that a_dimensionless_type is actually dimensionless?
    //the rest of the function
  }

我想要以下示例进行编译

  vec<si::dimensionless> d(10, 2.0);
  vec<si::length>  l(10, …

我正在实现一个消息传递算法.当消息在节点处具有足够的信息来组成消息时,消息在相邻节点之间传递 - 从相邻节点传递到节点的信息.如果我将每个消息都设置为一个线程并使用boost :: condition将线程置于休眠状态直到所需信息可用,那么实现是微不足道的.

不幸的是 - 我在图中有100k节点,这意味着300k线程.当我问如何制作那么多线程时,答案是我不应该 - 而是重新设计.

我的问题是:是否存在等待条件的标准设计模式？ 也许是一些异步控制模式？

编辑:我想我可以用proacator模式做到这一点.我已经编辑了标签以包含boost :: asio - 以查看是否有人对此有任何建议.

所以讨论可以是具体的,这里是到目前为止如何定义消息:

class
Message
{
public:      
  Message(const Node* from, Node* to)
    : m_from(from), m_to(to)
  {}
  void
  operator()()
  {
    m_to->ReceiveMessage( m_from->ComposeMessage() );
  }
private:
  Node *m_from, *m_to;
};

这些消息函子目前使用boost :: thread启动.然后我们有

class Node
{
    Node(Node* Neighbour1, Node* Neighbour2, Node* Neighbour3); 
   // The messages (currently threads) are created on construction, 
   // The condition locks then sort out when they actually get passed 
   // …

所有互斥实现最终都会调用相同的基本系统/硬件调用 - 这意味着它们可以互换吗？

具体来说,如果我正在使用__gnu_parallel算法(使用openmp)并且我想创建它们调用线程安全的类可以boost::mutex用于锁定吗？或者我必须编写自己的互斥锁,例如此处描述的互斥锁

//An openmp mutex.  Can this be replaced with boost::mutex? 
class Mutex {  
public:
    Mutex() { omp_init_lock(&_mutex); }
    ~Mutex() { omp_destroy_lock(&_mutex); }
    void lock() { omp_set_lock(&_mutex); }
    void unlock() { omp_unset_lock(&_mutex); }
private:
    omp_lock_t _mutex;
};

编辑,上面的openmp mutex链接似乎被打破了,对于任何感兴趣的人来说,与这个互斥锁一起使用的锁是沿着这些线

class Lock
{
public:
    Lock(Mutex& mutex) 
        : m_mutex(mutex), 
    m_release(false) 
    { 
        m_mutex.lock();
    }

    ~Lock() 
    {
        if (!m_release) 
            m_mutex.unlock(); 
    }

    bool operator() const 
    {
        return !m_release; 
    }

    void release()
    {
        if (!m_release) …

我正在重新熟悉Perl,并且刚刚用来module-starter初始化一个新项目.我现在正试图理解生成的代码.一切都很好,除了以下指示:

sub not_in_file_ok {
  my ($filename, %regex) = @_;
  open( my $fh, '<', $filename )
    or die "couldn't open $filename for reading: $!";

  my %violated;

  while (my $line = <$fh>) {
    while (my ($desc, $regex) = each %regex) {
        if ($line =~ $regex) {
            ##I'm having problems here
            push @{$violated{$desc}||=[]}, $.;
        }
    }
  }
  ...
}

我有两个问题:

1. 的||=[].这是|其次|=,还是这一个或||后跟=[].有人能跟我说说这里发生的事吗？(我猜测"如果散列是空的,则创建一个空的匿名数组来初始化散列",但我很难看到它是如何从代码中形成的.)
2. push @{$violated{$desc}}, $. 我明白这意味着"的行号分配给该键$desc的散列%violated,但是从I读取,代码"查找密钥的值desc的 …