Как избежать дублирования кода при написании константного и не константного метода?

@Аким2020 · Регистрация: 05.10.2020

Author24 — интернет-сервис помощи студентам

Есть класс Buffer, который содержит метод forBounds, который в качестве параметров принимает вспомогательный класс Bounds и шаблонный элемент _Func, который должен быть лямбда-функцией, в которой описывается логика. В общем, сам метод чем-то напоминаем функцию std::for_each. Проблема заключается в том, что мне нужно как-то сделать два метода const и не const версию. Дублировать код и писать макросы как-то не хочется.

Есть ли способ, как можно сделать два одинаковых по коду метода, но так, чтобы один был const, а другой нет, но при этом избежать дублирования?

C++

template<typename _T>
template<typename _Func>
inline bool Buffer<_T>::forBounds(const Bounds& bounds, const _Func& func) const
{
    if (!getBounds().isContain(bounds))
    {
        CERR_ERROR(STR_ERROR_VIOLATION_OF_BUFFER_BOUNDS)
        return false;
    }
    const size_t start_index = bounds.getStartCell().toIndex(m_dimension);
    const size_t finish_index = bounds.getFinishCell().toIndex(m_dimension);
    const size_t width = bounds.getWidth();
    const size_t step = getNumberOfColumns() - width;
    size_t current_col = 1;
    for (size_t i = start_index; i <= finish_index; i++)
    {
        func(at(i));
        if (current_col % width == 0)
        {
            current_col = 1;
            i += step;
        }
        else
            current_col++;
    }
    return true;
}
 
template<typename _T>
template<typename _Func>
inline bool Buffer<_T>::forBounds(const Bounds& bounds, const _Func& func)
{
    //Надо что-то сделать, чтобы не дублировать код.
}

@hoggy · 01.03.2022, 01:21

Сообщение от John Prick

тип this в таком методе - const Bounds * const.

ты ошибаешься.

this не может быть const t,
поскольку ключевое слово обозначает prvalue,
для которого отбрасывается верхний const.

пример:
https://rextester.com/IRRMSL71179

C++

//  warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
const int* const ptr();
 
int main(){}

Сообщение от Аким2020

Если есть идеи лучше, пожалуйста, скажите мне.

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

и когда я пишу: "минимальный пример-иллюстрацию",
то имею ввиду полноценную программу,
которая включает в себя функцию main,
и все необходимые детали,
а не огрызки.

Сообщение от Аким2020

_template_params_

UB

Алексей1153 · 01.03.2022, 06:30

Аким2020, захват в лямбде ссылки или указателя на буфер сильно всё упростит, в том числе и отладку.

@Аким2020 · 01.03.2022, 10:23 **[ТС]**

hoggy,

C++

int main()
{
    const Buffer<int> buffer_const =
    {
        {1,2,3,4,5},
        {6,7,8,9,10},
        {11,12,13,14,15},
        {16,17,18,19,20},
        {21,22,23,24,25}
    };
    auto buffer_non_const = buffer_const;
 
    buffer_const.forEach([](int& element)// Ошибка т.к. лямбда может изменить состояние буффера, а буффер константный.
        {
            std::cout << element << std::endl;
        }
    );
    buffer_const.forEach([](const int& element)// Нет ошибки т.к. лямбда не может менять состояние буффера.
        {
            std::cout << element << std::endl;
        }
    );
    buffer_non_const.forEach([](int& element)// Нет ошибки т.к. буффер не конст.
        {
            std::cout << element << std::endl;
        }
    );
}

Вот что я хочу. Что бы в случае, если лямбда, способная изменять состояние буффера передавалась в метод константного объекта, происходила ошибка, а если бы передавалась в не конст. объект ошибки не было и лямбда могла бы изменять состояние объекта.

@SmallEvil · 01.03.2022, 10:37

Не по теме:

Аким2020, почему то мне кажется, что вы воюете с ветряными мельницами...

@Аким2020 · 01.03.2022, 10:41 **[ТС]**

SmallEvil, возможно...

@DrOffset · 01.03.2022, 11:17

Сообщение от Аким2020

Что бы в случае, если лямбда, способная изменять состояние буффера передавалась в метод константного объекта, происходила ошибка, а если бы передавалась в не конст. объект ошибки не было и лямбда могла бы изменять состояние объекта.

C++

template <typename T>
class Buffer {
public:
....................
    
    T const & front() const {
        return .............
    }
    T & front() {
        return ............
    }        
    template <typename Func>
    auto forEach(Func f) const -> std::void_t<decltype(f(this->front()))> {
        ...............
    }
    template <typename Func>
    auto forEach(Func f) -> std::void_t<decltype(f(this->front()))> {
        .............      
    }
    
private:    
    .................
};
 
 
 
 
int main()
{
    const Buffer<int> buffer_const =
    {
        {1,2,3,4,5},
        {6,7,8,9,10},
        {11,12,13,14,15},
        {16,17,18,19,20},
        {21,22,23,24,25}
    };
    
    auto buffer_non_const = buffer_const;
 
    buffer_const.forEach([](int & element)// Ошибка т.к. лямбда может изменить состояние буффера, а буффер константный.
        {
            std::cout << element << std::endl;
        }
    );
    buffer_const.forEach([](const int& element)// Нет ошибки т.к. лямбда не может менять состояние буффера.
        {
            std::cout << element << std::endl;
        }
    );
    buffer_non_const.forEach([](int& element)// Нет ошибки т.к. буффер не конст.
        {
            std::cout << element << std::endl;
        }
    );
}

Добавлено через 2 минуты
Или то же самое через концепты в C++20.

@Аким2020 · 01.03.2022, 11:50 **[ТС]**

DrOffset, но мне же все равно тут придется писать два одинаковых определения метода forEach. Для const и non-const.

C++

    template <typename Func>
    auto forEach(Func f) const -> std::void_t<decltype(f(this->front()))> {
        ...............
    }
    template <typename Func>
    auto forEach(Func f) -> std::void_t<decltype(f(this->front()))> {
        .............      
    }

@SmallEvil · 01.03.2022, 11:59

Сообщение от DrOffset

T const & front() const {
return .............
}
T & front() {
return ............
}

Да, это первое что приходит в голову, но проблему изначального вопроса не решает.
Вся суть константности, инкапсуляции не в том что бы зделать код "деревянным" или "железобетонным",
но как раз наоборот.

Аким2020, в Вашем случае, нет в необходимости в константном методе вообще.
Поэтому я долго не мог понять сути вопроса, проблемы.
Если ваш метод, изменяет данные, то он не может быть в априори константным.
При попытке вызова такой функции от константного объекта, получите compile time error.
В чем вопрос ?

Добавлено через 3 минуты
Или если метод не изменяет данные, то делайте его ТОЛЬКО константным.

@Аким2020 · 01.03.2022, 12:19 **[ТС]**

SmallEvil, const метод нужен для обхода коллекции без изменения самой коллекции. Сейчас попробую объяснить еще раз более подробно.

Вот то, как это работает с дублированием кода. То, как я хотел бы, чтоб это работало.

C++

#include <iostream>
#include <initializer_list>
#include <vector>
#include <algorithm>
 
template<typename _T>
class Buffer
{
private:
 
    std::vector<_T> m_vector;
 
public:
 
    Buffer(const std::initializer_list<_T>& init_list) :
        m_vector(init_list)
    {
    }
 
    template<typename _Func>
    void forEach(const _Func& func) const
    {
        std::for_each(m_vector.begin(), m_vector.end(), func);
    }
 
    template<typename _Func>
    void forEach(const _Func& func)
    {
        //Дублирование кода.
        //Тут не критично, но в моем проекте тут спяртана довольно-таки крупная логика.
        std::for_each(m_vector.begin(), m_vector.end(), func);
    }
};
 
int main()
{
 
    const Buffer<int> const_buffer = { 1,2,3,4,5 };
    //Этот метод нужен для обхода коллекции без изменения буффера. Например, для подсчета четных значений.
    //Тут будет ошибка, потому что в лябмду передана ссылка на элемент буффера.
    const_buffer.forEach([](int& el)
        {
        }
    ); std::cout << std::endl;
 
 
    //А тут ошибки не будет, потому что лямбда принимает const элемент и изменить состояние буффера не сможет.
    const_buffer.forEach([](const int& el)
        {
        }
    ); std::cout << std::endl;
 
 
    auto non_const_buffer = const_buffer;
    //Этот метод нужен для обхода коллекции с возможностью изменения буффера. Например, для замены четныхх значний - цифрой 0.
    //Тут ошибки не будет, потому что буффер не конст.
    non_const_buffer.forEach([](int& el)
        {
        }
    ); std::cout << std::endl;
 
 
 
}

А теперь я пробую убрать дублирование кода, вызовом const метода из non-const, как мне предлагали ранее.

C++

template<typename _T>
class Buffer
{
private:
 
    std::vector<_T> m_vector;
 
public:
 
    Buffer(const std::initializer_list<_T>& init_list) :
        m_vector(init_list)
    {
    }
 
    template<typename _Func>
    void forEach(const _Func& func) const
    {
        std::for_each(m_vector.begin(), m_vector.end(), func);
    }
 
    template<typename _Func>
    void forEach(const _Func& func)
    {
        return std::as_const(*this).forEach(func);
    }
};
 
int main()
{
 
    Buffer<int> non_const_buffer = { 1,2,3,4,5 };
    //Будет ошибка, т.к. я вызову const метод и передам в него лямбду способную изменить состояние буффера
    //То есть, вызывая non-const метод для non-const буффера, я вызову const метод.
    non_const_buffer.forEach([](int& el)
        {
        }
    ); std::cout << std::endl;
 
 
 
}

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

@DrOffset · 01.03.2022, 12:21

Аким2020,

C++

template <typename T>
class Buffer {
public:
    ..............
        
    T const & front() const {
        return .....
    }
    T & front() {
        return ....
    }        
    template <typename Func>
    auto forEach(Func f) const -> std::void_t<decltype(f(this->front()))> {
        const_cast<Buffer*>(this)->forEachImpl(f);
    }
    template <typename Func>
    auto forEach(Func f) -> std::void_t<decltype(f(this->front()))> {
        forEachImpl(f);    
    }
    
private:
    template <typename Func>
    void forEachImpl(Func f) {
        for(auto & v : m_buf) {
            f(v);    
        }
    }
    
private:    
    .... m_buf;
};

@Аким2020 · 01.03.2022, 12:35 **[ТС]**

SmallEvil,

Сообщение от SmallEvil

Или если метод не изменяет данные, то делайте его ТОЛЬКО константным.

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

Возможно, для метода, который обходит каждый элемент коллекции - это выглядит глупо, но в моем класс Buffer, который в заглавии этой темы, метод forBounds прячет в себе некую логику.

Добавлено через 10 минут
DrOffset, вот это, вроде, работает, как надо. Сейчас разберусь до конца и скажу точно.

@DrOffset · 01.03.2022, 12:59

Сообщение от Аким2020

вот это, вроде, работает, как надо.

Это ничем не отличается от того, что было до этого, за исключением раскрытия тел методов.
Конкретно этот прием с кастом можно рассмотреть в книге Мейерса (точно не помню в какой, кажется в Эффективное использование C++ - 55 советов). Это не очень распространенный прием и довольно спорный, и в некоторых случаях его использование небезопасно, но если вы приняли меры предосторожности, то вполне допустимый.

Можно и без кастов обойтись, если сделать шаблонную функцию, или воспользоваться стандартной:

C++

template <typename T>
class Buffer {
public:
    T const & front() const { return m_buf.front(); }
    T & front() {  return m_buf.front(); }   
    
    template <typename Func>
    auto forEach(Func f) const -> std::void_t<decltype(f(this->front()))> {
        std::for_each(m_buf.begin(), m_buf.end(), f);
    }
    template <typename Func>
    auto forEach(Func f) -> std::void_t<decltype(f(this->front()))> {
        std::for_each(m_buf.begin(), m_buf.end(), f);
    }
 
private:
    
private:    
    std::vector<T> m_buf;
};

Вот здесь, например, нет никакого дублирования кода.

Добавлено через 10 минут

Не по теме:

Сообщение от DrOffset

кажется в Эффективное использование C++ - 55 советов

Да, на 37 странице в русском издании.

@Аким2020 · 01.03.2022, 13:23 **[ТС]**

DrOffset, возвращаемый тип auto. Не подскажите, как можно указать, например, bool?

@DrOffset · 01.03.2022, 13:27

Сообщение от Аким2020

возвращаемый тип auto.

Возвращаемый тип void, если что

Сообщение от Аким2020

Не подскажите, как можно указать, например, bool?

C++

template <typename T>
class Buffer {
public:
    T const & front() const { return m_buf.front(); }
    T & front() {  return m_buf.front(); }   
    
    template <typename Func>
    auto forEach(Func f) const -> decltype(f(this->front()), bool()) {
        std::for_each(m_buf.begin(), m_buf.end(), f);
        return true;
    }
    template <typename Func>
    auto forEach(Func f) -> decltype(f(this->front()), bool()) {
        std::for_each(m_buf.begin(), m_buf.end(), f);
        return true;
    }
 
private:
    
private:    
    std::vector<T> m_buf;
};

PS. если у вас доступен C++20, то пользуйтесь концептами вместо SFINAE.

@Аким2020 · 01.03.2022, 13:43 **[ТС]**

DrOffset, ну, вы гений получается.

Все работает даже лучше, чем я себе представлял. Спасибо вам огромное, а-то я уже с макросом думал смириться(