Блог

У меня есть класс CS, который должен представлять систему координат в 3D, т.Е. (x, y, z)

 class CS
{
  private:
        double x;
        double y;
        double z;
}

CS::CS()
{
   x = NULL;//this causes x = 0//i want the address of x to be 0x000000 amp; not x = 0
   y = NULL;
   z = NULL:
}
  

Я хочу, чтобы пользователь мог создать CS (0, 0, 0).
В конструкторе я хочу инициализировать адреса x, y и z равными НУЛЮ.
это делается для того, чтобы различать определяемое пользователем (0, 0, 0) и значение по умолчанию.
Я создаю объекты CS динамически, поэтому нет смысла использовать следующий код:

 class CS
{
  private:
        double *x;
        double *y;
        double *z;
}

CS:CS()
{
    x = new double;
    x = NULL;
    //same for y amp; z
}
  

Прежде всего, я хочу вручную присвоить адрес 0x000000 любой переменной (int или double или char) без использования указателей.
есть предложения?

Вы не можете изменить позиции x, y и z на NULL, поскольку там позиции всегда будут смещены от объекта CS. Они всегда будут существовать. Это не значит, что CS у x вас есть машина, это CS похоже на x то, что у вас есть голова. У вас не может не быть головы. Если бы они были целыми числами, вам пришлось бы сделать их указателями (как вы сказали, что не хотите этого делать), потому что это был бы единственный способ отличить неинициализированное от инициализированного. Однако у double s есть магическое значение, которое редко используется:

 CS:CS()
: x(std::numeric_limits<double>::quiet_NaN())
: y(std::numeric_limits<double>::quiet_NaN())
: z(std::numeric_limits<double>::quiet_NaN())
{ }
  

Пользователи, вероятно, не будут устанавливать значения x, y и z (НЕ ЧИСЛО) намеренно.

Прежде всего, я хочу вручную присвоить адрес 0x000000 любой переменной (int или double или char) без использования указателей. есть предложения?

Это не то, что вы хотите. Что вам нужно, так это возможность определять, была ли установлена переменная или нет.

Другие предлагали такие вещи, как использование определенного значения с плавающей запятой для определения неинициализированного состояния, но я предлагаю использовать Boost .Необязательно. Рассмотрим:

 class CS
{
  private:
    boost::optional<double> x;
    boost::optional<double> y;
    boost::optional<double> z;
}
  

boost::optional либо сохраняет тип, который вы задаете параметру шаблона, либо ничего не сохраняет. Вы можете проверить разницу с помощью простого логического теста:

 if(x)
{
  //Has data
}
else
{
  //Has not been initialized
}
  

Недостатком является то, что доступ к данным немного сложнее:

 x = 5.0; //Initialize the value. x now has data.
y = 4.0 * x; //Fails. x is not a double; it is an optional<double>.
y = 4.0 * (*x); //Compiles, but only works at runtime if x has a value.
  

У вас есть несколько вариантов:

1. Используйте указатели.
2. Используйте логический флаг рядом с каждой переменной, указывающий, была ли установлена переменная.
3. Если диапазон допустимых значений ограничен, вы можете использовать специальное значение для обозначения «не установлено». Для double not-a-number часто является естественным кандидатом. Для int и char часто сложнее выбрать хорошее значение.

Ни один из этих вариантов, бесспорно, не лучше двух других, поскольку они предполагают разные компромиссы. Выбирайте сами.

Почему вы не можете просто сделать это:

 class CS
{
public:
    // Constructs a CS initialized to 0, 0, 0
    CS() : x(0), y(0), z(0), is_initialized(false) {}

    // User defined values
    CS(double newX, double newY, double newZ) : x(newX), y(newY), z(newZ), is_initialized(true) {}

private:
    double x;
    double y;
    double z;

    // If you need to know that this was initialized a certain way, you could use this suggestion from the comments:
    bool is_initialized;
}
  

Если я правильно понимаю, вы хотите иметь возможность определить разницу между недопустимым, сконструированным по умолчанию CS и допустимым CS со значениями (0.0, 0.0, 0.0) . Это именно то, что boost::optional http://www.boost.org/doc/libs/1_47_0/libs/optional/doc/html/index.html это для.

Вы не можете представить его в том же количестве битов, не имея часового. Если 0 является допустимым числом, вы не можете его использовать. Если вы попытаетесь внедрить обработку null в тип значения, вы получите принципиально неверный и недостижимый код.

При правильной обработке нулей вы ожидаете увидеть такой интерфейс:

 struct foo {
  virtual ~foo() {}
  virtual bool getX(double amp;val) = 0;
  virtual bool getY(double amp;val) = 0;
  virtual bool getZ(double amp;val) = 0;
};
  

Реализация может иметь флаг, который она проверяет перед доступом.

 void some_func(foo *f) {
  double x, y, z;
  if (f->getX(x) amp;amp; f->getY(y) amp;amp; f->getZ(z)) {
    cout << x << ", " << y << ", " << z << endl;
  } else {
    throw std::logic_error("expected some values here");
  }
}
  

Вы не хотите использовать недопустимое значение и не знать его. Очевидно, что проверять возвращаемые значения утомительно, но это дает вам максимальный контроль. У вас также могут быть помощники или перегрузки, которые будут выдавать, если они недействительны.

 struct bar {
  double getX() {
    if (!valid)
      throw std::logic_error("bar is not valid");
    return x;
  }
  bool valid;
  double x, y, z; 
}
  

Для меня разница между foo и bar заключается в том, что низкоуровневый код, обрабатывающий данные, не должен применять политику наличия данных или нет. На более высоких уровнях абстракции вы можете и должны ожидать, должны ли данные быть действительными, когда вы собираетесь их использовать. Оба могут существовать в системе, но foo необходимы.

Одним из способов получить семантику того, что вы хотите, было бы, чтобы тип данных координат был типом, который содержит значение, указывающее, было ли оно присвоено. Что-то вроде этого.

 template<typename T>
class CoordinateValue {
   public:
       CoordinateValue() : uninitialized(true), val(0) {}
       CoordinateValue(T x) : uninitialized(false), val(x) {}
       void setVal(T x) {val = x; uninitialized= false}
       // Trivial getters
    private:
       T val;
       bool uninitialized;
};
  

Я бы предпочел что-то подобное более приятным методам, если только по какой-то причине памяти действительно не хватает.

Если координаты либо все по умолчанию, либо все заданы, тогда у вас может быть один флаг, а не тип данных координат, который включает флаг.

Я хочу, чтобы пользователь мог создать CS (0, 0, 0). В конструкторе я хочу инициализировать адреса x, y и z равными НУЛЮ. это делается для того, чтобы различать определяемое пользователем (0, 0, 0) и значение по умолчанию. Я создаю объекты CS динамически, поэтому нет смысла использовать следующий код:

В этом проблема. Во-первых, значение по умолчанию? Какое значение по умолчанию? Почему должно быть значение по умолчанию? Это неправильно. И, во-вторых, для вас принципиально невозможно изменить адрес какой-либо переменной.

То, что вы хотите, невозможно выполнить, и даже если бы это было возможно, это было бы ужасно плохой идеей.

Вы не можете изменить адрес переменной. И вы не можете присваивать значения указателя (например NULL , или nullptr в C ) переменной не указательного типа, например double .