Question

我在我的C ++项目中使用GNU Scientific Library。为了方便起见，我想将gsl_vector*包含在C ++类中（添加一组特定于域的函数并简化界面）。但我对如何处理const gsl_vector*感到困惑。让我解释。让我从这个简约的包装器开始。

class Vector {
  gsl_vector* vector_;
public:
  Vector(gsl_vector* vector): vector_(vector) {}
  double& operator()(int i) {
    return *gsl_vector_ptr(vector_, i);
  }
};

进一步假设我有两个功能。一个定义如下：

int f(Vector& x) {
  \\ do some math, e.g. x(0) = 0.0;
  return 0;
}

另一个是必须使用GSL类型的回调函数，定义如下：

int gsl_f(gsl_vector* x) {
  Vector xx(x);
  return f(xx);
}

这很好用。现在，假设回调具有常量签名：

int gsl_f(const gsl_vector* x);

然后我可以相应地重新定义我的Vector课程和我的f职能：

class Vector {
  const gsl_vector* vector_;
public:
  Vector(const gsl_vector* vector): vector_(vector) {}
  const double& operator()(int i) const {
    return *gsl_vector_const_ptr(vector_, i);
  }
};

int f(const Vector& x) {
  \\ do some math 
  return 0;
}

也有效。现在，我希望我的包装类适合这两种情况。例如，我希望能够执行以下操作，保持const 的安全性：

int f(const Vector& x, Vector& y) {
  \\ do some math 
  return 0;
}

int gsl_f(const gsl_vector* x, gsl_vector* y) {
  Vector yy(y);
  return f(x, yy);
}

我可以通过使用带有两个指针的Vector来构建它，const和非const，并记住它是从const或非const成员初始化的。我的问题是，如果没有运行时检查，我可以这样做吗？毕竟，所有信息都在编译时存在。

Answer 1

组合这两个类应该按预期工作，你试过吗？

class Vector {
  gsl_vector* vector_;
public:
  Vector(gsl_vector* vector): vector_(vector) {}

  const double& operator()(int i) const {
    return *gsl_vector_ptr(vector_, i);
  }
  double& operator()(int i) {
    return *gsl_vector_ptr(vector_, i);
  }

  operator const_Vector()
  { 
    return const_Vector(vector_);
  }

};


class const_Vector {
  const gsl_vector* vector_;
public:
  const_Vector(const gsl_vector* vector): vector_(vector) {}

  const double& operator()(int i) const {
    return *gsl_vector_ptr(vector_, i);
  }
};

函数签名需要这样：

int f(const_Vector& x, Vector& y) {
  \\ do some math 
  return 0;
}

这遵循类似于iterator和const_iterator的方案。

也许你的情况不会奏效。你应该发布这种情况，我们可以尝试解决它。

Answer 2

提案（不太好，但应该有效）：

class Vector { 
  gsl_vector* vector_;
  const gsl_vector* const_vector_; 
public: 
  Vector(const gsl_vector* vector): vector_(nullptr), const_vector_(vector) {} 
  Vector(gsl_vector* vector): vector_(vector), const_vector_(vector) {}
  const double& operator()(int i) const { 
    return *gsl_vector_ptr(const_vector_, i); 
  } 
  double& operator () (int i) {
    return *gsl_vector_ptr(vector_, i);
  }
};

第二种可能性：

class Vector { 
private:
  gsl_vector* vector_;

  Vector(gsl_vector* vector): vector_(vector) {}

public:
  static const Vector* Create (const gsl_vector* vector) {
     return new Vector (const_cast<Vector *> vector);
  }

  static Vector* Create (gsl_vector* vector) {
     return new Vector (vector);
  }

  const double& operator()(int i) const { 
    return *gsl_vector_ptr(vector_, i); 
  } 
  double& operator () (int i) {
    return *gsl_vector_ptr(vector_, i);
  }
};

Answer 3

您还可以使用某种类型的继承来指向数据。此外 - 模板可用于创建重载函数，根据输入指针类型返回一个或第二个版本。

class JSONChannelFullConfigConst:
        public JSONObjectRenderer {
public:
    JSONChannelFullConfigConst(const uint8_t * channel_id,
                               const sensors_single_channel_config_t * cfg) :
                    j_channel_id(channel_id),
                    j_cfg(cfg) {

    }

private:
    const uint8_t * const j_channel_id;
    const sensors_single_channel_config_t * const j_cfg;
    void renderFields(rlf::UcOstreamBase& os) const;
    public:
    uint8_t getId() const {
        return *j_channel_id;
    }
};

class JSONChannelFullConfig:
        public JSONChannelFullConfigConst,
        public JSONObjectParser {
public:
    JSONChannelFullConfig(uint8_t * channel_id, sensors_single_channel_config_t * cfg) :
                    JSONChannelFullConfigConst(channel_id, cfg),
                    j_channel_id(channel_id),
                    j_cfg(cfg) {

    }
    void setId(uint8_t id) {
        *j_channel_id = id;
    }
private:
    uint8_t * const j_channel_id;
    sensors_single_channel_config_t * const j_cfg;

    virtual bool parseNameValuePair(const char * name, rlf::UcIstream & value);
};

const和非const指针的统一包装器

3 个答案: