围绕常量指针和非常量指针的统一包装

Unified wrapper around const and non-const pointers

本文关键字：指针 常量 包装 非常      更新时间：2023-10-16

我在C++项目中使用GNU科学库。为了方便起见，我想将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);
}

我可以通过使用具有两个指针（const和nonconst）的Vector，并记住它是从const还是nonconst成员初始化的。我的问题是，我可以在没有运行时检查的情况下完成它吗？毕竟，在编译时所有的信息都在那里。

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

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);
  }
};

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

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;
}

这遵循类似于迭代器和const_iterator的方案。

也许你有一种情况，这是行不通的，。你应该发布这种情况，我们可以尝试解决它。

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

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);
};
相关文章：