приколы с операторами

Dizer

✩✩✩✩✩✩✩
3 Янв 2022
7
0
нужно чтобы к классу Test можно было обращаться как к массиву.
C++:
class Test {
public:
    int* array;
    ~Test() { delete[]array; }

    Test(int x) {
        array = new int[x] {0};
    }
private:
};

int main() {
    Test a(10);    //класс в котором массив на 10 ячеек

    //вот так должно выглядеть
    a[1] = -1;
    cout << a[1];

    return 0;
}
 

bort707

★★★★★★★
21 Сен 2020
3,538
1,009
И где тут операторы?
Хотите обращаться к классу как массиву - начните с переопределения оператора []
 

Dizer

✩✩✩✩✩✩✩
3 Янв 2022
7
0
@bort707, Да, я хочу обращаться к классу как массиву. Я могу написать оператор чтобы получить из массива значение
C++:
int operator[](int x) {
        return array[x];
}
но не знаю как присвоить этому массиву значение
C++:
a[1] = -1;  //ошибка
 

bort707

★★★★★★★
21 Сен 2020
3,538
1,009
Так вы создали оператор для извлечения значения, а для присваивания где?
 

Dizer

✩✩✩✩✩✩✩
3 Янв 2022
7
0
@bort707,в этом и прикол. я не знаю как его описать. Если вас не затруднит напишите его.
 

Kir

★✩✩✩✩✩✩
28 Мар 2020
71
17
@Dizer,
Нужно возвращать не значение, а ссылку: int& operator[](int x) { return array[x]; }
Однако принимать int в качестве аргумента не самая лучшая идея, так как могут передать отрицательное значение, поэтому лучше сделать так:
int& operator[](size_t x) { return array[x]; }, кроме того, было бы не плохо проверить выход за границу массива.

PS: Если у вас нет задачи написать свой std::vector, то лучше использовать std::vector, который все это реализует, и даже больше, и надежнее.
 
  • Лойс +1
Реакции: Dizer

Dizer

✩✩✩✩✩✩✩
3 Янв 2022
7
0
@Kir,
Спасибо.
По сути да, я хотел переписать std::vector, но только в ознакомительных целях.
 

Kir

★✩✩✩✩✩✩
28 Мар 2020
71
17
@bort707, size_t - это переносимый тип, которого гарантированно хватит для хранения размера любого непрерывного участка памяти для конкретной машины, а значит гарантировано подойдет для индексирования массива любого размера, на конкретной машине. Кроме того оператор sizeof возвращает значение типа std::size_t, можно об этом почитать в стандарте на язык с++.
 

SergejEU

★★✩✩✩✩✩
16 Сен 2020
120
74
size_t - это переносимый тип, которого гарантированно хватит для хранения размера любого непрерывного участка памяти для конкретной машины, а значит гарантировано подойдет для индексирования массива любого размера
если вы печётесь о переносимости типов, то почему сразу не использовать базовый тип ptrdiff_t, который для этой цели прямо и создан? Зачем останавливаться на пол-пути?
 

Kir

★✩✩✩✩✩✩
28 Мар 2020
71
17
@SergejEU, ptrdiff_t - это знаковый тип, а в данном случае нужен беззнаковый.
 

SergejEU

★★✩✩✩✩✩
16 Сен 2020
120
74
@Kir,
ваша отмазка не катит. В посте #6 вы вещаете о типе int, а вам писал о другом - ptrdiff_t. Можно ведь было сделать домашнее задание, например почитать стандарты о Переносимости типов size_t и ptrdiff_t или Безопасность типов ptrdiff_t и size_t в адресной арифметике? Зачем вдруг стал нужен знаковый тип?

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

Kir

★✩✩✩✩✩✩
28 Мар 2020
71
17
@SergejEU, хорошо, давайте обсудим:
ptrdiff_t -выдержка из стандарта "The type ptrdiff_t is an implementation-defined signed integer type that can hold the difference of two subscripts in an array object, as described in 7.6.6."
size_t - выдержка из стандарта "The type size_t is an implementation-defined unsigned integer type that is large enough to contain the size in bytes of any object (7.6.2.4)"

задача, переопределить operator[], для класса, внутри которого инкапсулирован массив, в качестве аргумента принимаем индекс, по которому нужно получить элемент массива.

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

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

Сравним, что выгоднее сделать 2 проверки, или 1, мне лично кажется что 1 делать дешевле.
Предлагаю заглянуть в реализацию std::vector, ведь именно его пытались повторить, что там видим:
C++:
      _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
      reference
      operator[](size_type __n) _GLIBCXX_NOEXCEPT
      {
    __glibcxx_requires_subscript(__n);
    return *(this->_M_impl._M_start + __n);
      }
а что значит size_type
C++:
 typedef size_t size_type;
Авторы стандартной библиотеки почему-то тоже считают, что лучше использовать size_t
При этом, что интересно, в реализации operator[] нет проверки выхода за границы массива, однако, в комментарии который я не стал вставлять, но который можно найти в исходнике, говорят, что в методе at() есть проверка, предлагаю заглянуть туда:

C++:
    protected:
      /// Safety check used only from at().
      _GLIBCXX20_CONSTEXPR
      void
      _M_range_check(size_type __n) const
      {
    if (__n >= this->size())
      __throw_out_of_range_fmt(__N("vector::_M_range_check: __n "
                       "(which is %zu) >= this->size() "
                       "(which is %zu)"),
                   __n, this->size());
      }

    public:
      /**
       *  @brief  Provides access to the data contained in the %vector.
       *  @param __n The index of the element for which data should be
       *  accessed.
       *  @return  Read/write reference to data.
       *  @throw  std::out_of_range  If @a __n is an invalid index.
       *
       *  This function provides for safer data access.  The parameter
       *  is first checked that it is in the range of the vector.  The
       *  function throws out_of_range if the check fails.
       */
      _GLIBCXX20_CONSTEXPR
      reference
      at(size_type __n)
      {
    _M_range_check(__n);
    return (*this)[__n];
      }
Действительно есть проверка.

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

SergejEU

★★✩✩✩✩✩
16 Сен 2020
120
74
@Kir, давайте обсудим.. Я бы промолчал и не стал влезать в обсуждение, но вы сами противоречите себе. Если бы вы написали, что как один из вариантов переопределения оператора я вижу так-то и так-то, то никаких проблем, это ваше право. Но вы идете дальше и предлагаете, цитирую #6: "кроме того, было бы не плохо проверить выход за границу массива". Что это значит, а то, что необходимо применить оператор сравнения с неявным или явным приведением типов; необходимо применить адресную арифметику - посчитать разность указателей, потом сравнить полученный результат. И тут возможны варианты и самые неожиданные сюпризы, способные возникнуть на некоторых платформах и для некоторых настройках компилятора. И как вы решили сравнивать безнаковое целое и отрицательный результат, да еще, если это происходит в неявном виде? Так где же ваша хваленная переносимость? Если вы собрались говорить А, то нужно говорить и Б.
 

poty

★★★★★★★
19 Фев 2020
3,699
1,060
@SergejEU, не очень понимаю, причём тут разность указателей и адресная арифметика? Размер массива определяется на этапе его создания (и даже если потом изменяется - всё равно известен явно). Это значит, что нужно обеспечить (при unsigned) сравнение переданного в класс индекса только с максимальным значением, которое равно размеру массива минус единица. Мы же оперируем "элементами массива", а не байтами в памяти.
 
  • Лойс +1
Реакции: Kir

SergejEU

★★✩✩✩✩✩
16 Сен 2020
120
74
не очень понимаю, причём тут разность указателей и адресная арифметика?
Потому что индексация в массивах с использованием квадратных скобок – это всего лишь иная запись адресной арифметики. Всякий раз, обращаясь к элетантам массива, мы выполняем действия адресной арифметики. Это как в пьесе Мольера один персонаж - господин Журден не знал, что всю свою жизнь он говорил именно прозой.

Не важно был или не был заранее известен размер массива, все равно придется сравнивать указатели на.. Вот наглядный пример, где из-за неявного приведения типов, код работает на 32-битной платформе, но не работает на 64-битной. И это еще цветочки, есть другие более содержательные примеры с операторами сравнения.

C++:
int A = -2;
unsigned B = 1;
int array[5] = { 1, 2, 3, 4, 5 };
int *ptr = array + 3;
ptr = ptr + (A + B); //Invalid pointer value on 64-bit platform
printf("%i\n", *ptr); //Access violation on 64-bit platform
 
Изменено:

poty

★★★★★★★
19 Фев 2020
3,699
1,060
@SergejEU, во-первых, если индекс определяется одним типом, то никаких неявных преобразований не делается, в этом и была мысль использования size_t.
Во-вторых, предлагалось как раз отказаться от знаковых типов, который использован Вами в примере.
В-третьих, с чего Вы взяли, что физическое воплощение массива в классе будет соответствовать олдскульным нормам непрерывности выделенной области? А ведь именно это приводит к понятию эквивалентности адресной арифметики и индексации массива.
 

Kir

★✩✩✩✩✩✩
28 Мар 2020
71
17
@SergejEU, Вы забываете, что мы говорим о взаимодействии с классом, который синтаксически выглядит как взаимодействие с массивом, но по факту будет вызываться метод, в котором можно обработать возможные ошибки, перед фактическим обращением к "сырому" массиву.
Вот иллюстрация того, что будет происходить
 

SergejEU

★★✩✩✩✩✩
16 Сен 2020
120
74
Если в качестве аргумента использовать переменную size_t, если кто-то попытается отправить отрицательное значение, оно будет неявно приведено к беззнаковому типу, таким образом нужно сделать только одну проверку на выход за верхнюю границу.

Сравним, что выгоднее сделать 2 проверки, или 1, мне лично кажется что 1 делать дешевле.
Вы заблуждаетесь. Откуда вы взяли, что всегда и в всех возможных случаях приведенное итрицательное число/индекс к безнаковому окажется за пределами массива? Это может зависеть от настроек, платформы и использованого типа - char short int ect. Даёте гарантию, что этого не произойдёт никогда? Ну вот, преимущество size_t перед ptrdiff_t эфемерно. Соглашайтесь наконец и на этом закроем тему.
 

Kir

★✩✩✩✩✩✩
28 Мар 2020
71
17
@SergejEU,
Откуда вы взяли, что всегда и в всех возможных случаях приведенное итрицательное число/индекс к безнаковому окажется за пределами массива?
Представление отрицательных целых чисел

Это может зависеть от настроек, платформы и использованого типа - char short int ect
Поэтому и нужно использовать переносимые типы данных.


Ну вот, преимущество size_t перед ptrdiff_t эфемерно
Каждый тип имеет место применения, в конкретном случае преимущество size_t очевидное.
Очередной эфемерный пример

Соглашайтесь наконец и на этом закроем тему
Соглашаться с чем? С использованием типа ptrdiff_t для реализации operator[] как в std::vector, вместо size_t - не согласен, причины несогласия изложены в предыдущих постах, кроме того в библиотечной реализации std::vector используется size_t, впрочем об этом я также упоминал.
 

SergejEU

★★✩✩✩✩✩
16 Сен 2020
120
74
Соглашаться с чем?
Сначала согласитесь с вашим заблуждением. Для этого перечитайте мой пост #21 и запустите на исполнение привеведенный мною ниже контрпример. Если правы вы, цитата
Если в качестве аргумента использовать переменную size_t, если кто-то попытается отправить отрицательное значение, оно будет неявно приведено к беззнаковому типу, таким образом нужно сделать только одну проверку на выход за верхнюю границу.
то он подтвердит ваше предсказание, в противном случае вам следует повторить азы науки. Ничего в том зазорного нет, все мы когда-то заблуждаемся, но упорствовать и не признавать своих ошибок это уже перебор
C++:
// requires 64-bit platforms, GNU GCC
#include <iostream>
#include <cstdlib>

int main( void ) {
  
    long int index = -4294967296;
    size_t number = 18446744069414584320UL;
  
    std::cout << "number = " << number << std::endl;
    std::cout << "index = " << index << std::endl;

    if ( number < index ) {
        std::cout << "Your prediction is ok"  << std::endl;
    }
    else {
        std::cout << "go learn your lessons!" << std::endl;
    } 
  
    return 0;
}