ฉันจะลบการทำสำเนารหัสระหว่างฟังก์ชั่นสมาชิกแบบ const และ non-const ที่คล้ายกันได้อย่างไร

สมมติว่าฉันมีสิ่งต่อไปนี้class Xที่ฉันต้องการคืนการเข้าถึงสมาชิกภายใน:

class Z
{
    // details
};

class X
{
    std::vector<Z> vecZ;

public:
    Z& Z(size_t index)
    {
        // massive amounts of code for validating index

        Z& ret = vecZ[index];

        // even more code for determining that the Z instance
        // at index is *exactly* the right sort of Z (a process
        // which involves calculating leap years in which
        // religious holidays fall on Tuesdays for
        // the next thousand years or so)

        return ret;
    }
    const Z& Z(size_t index) const
    {
        // identical to non-const X::Z(), except printed in
        // a lighter shade of gray since
        // we're running low on toner by this point
    }
};

สมาชิกทั้งสองฟังก์ชั่นX::Z()และX::Z() constมีรหัสที่เหมือนกันภายในวงเล็บปีกกา นี่คือรหัสที่ซ้ำกันและอาจทำให้เกิดปัญหาการบำรุงรักษาสำหรับการทำงานที่ยาวนานกับตรรกะที่ซับซ้อน

มีวิธีการหลีกเลี่ยงการทำซ้ำรหัสนี้หรือไม่?

สำหรับคำอธิบายโดยละเอียดโปรดดูหัวข้อ "หลีกเลี่ยงการทำซ้ำในconstและconstฟังก์ชั่นที่ไม่ใช่สมาชิก" ในหน้า 23, ในรายการ 3 "ใช้constเมื่อใดก็ตามที่เป็นไปได้" ในC ++ ที่มีประสิทธิภาพ , 3d edโดย Scott Meyers, ISBN-13: 9780321334879

นี่คือวิธีแก้ปัญหาของ Meyers (ลดความซับซ้อน):

struct C {
  const char & get() const {
    return c;
  }
  char & get() {
    return const_cast<char &>(static_cast<const C &>(*this).get());
  }
  char c;
};

การปลดเปลื้องสองครั้งและการเรียกใช้ฟังก์ชันอาจน่าเกลียด แต่ก็ถูกต้อง เมเยอร์สมีคำอธิบายโดยละเอียดว่าทำไม

ใช่เป็นไปได้ที่จะหลีกเลี่ยงการทำซ้ำรหัส คุณจำเป็นต้องใช้ฟังก์ชั่นสมาชิก const ที่จะมีตรรกะและมีฟังก์ชั่นที่ไม่ใช่สมาชิก const เรียกฟังก์ชั่นสมาชิก const และหล่อค่าตอบแทนกลับไปอ้างอิง non-const (หรือตัวชี้ถ้าฟังก์ชั่นส่งกลับตัวชี้):

class X
{
   std::vector<Z> vecZ;

public:
   const Z& z(size_t index) const
   {
      // same really-really-really long access 
      // and checking code as in OP
      // ...
      return vecZ[index];
   }

   Z& z(size_t index)
   {
      // One line. One ugly, ugly line - but just one line!
      return const_cast<Z&>( static_cast<const X&>(*this).z(index) );
   }

 #if 0 // A slightly less-ugly version
   Z& Z(size_t index)
   {
      // Two lines -- one cast. This is slightly less ugly but takes an extra line.
      const X& constMe = *this;
      return const_cast<Z&>( constMe.z(index) );
   }
 #endif
};

หมายเหตุ:มันเป็นสิ่งสำคัญที่คุณไม่ได้ใส่ตรรกะในฟังก์ชั่นที่ไม่ใช่ const และมีฟังก์ชั่น const โทรฟังก์ชั่นที่ไม่ใช่ const - มันอาจส่งผลให้พฤติกรรมที่ไม่ได้กำหนด เหตุผลก็คืออินสแตนซ์ของคลาสคงที่ได้รับการคาสต์เป็นอินสแตนซ์ที่ไม่คงที่ ฟังก์ชันสมาชิกที่ไม่ใช่ const อาจแก้ไขคลาสโดยไม่ตั้งใจซึ่งสถานะมาตรฐาน C ++ จะส่งผลให้เกิดพฤติกรรมที่ไม่ได้กำหนด

C ++ 17 ได้อัปเดตคำตอบที่ดีที่สุดสำหรับคำถามนี้:

T const & f() const {
    return something_complicated();
}
T & f() {
    return const_cast<T &>(std::as_const(*this).f());
}

นี่คือข้อดีที่:

• เห็นได้ชัดว่าเกิดอะไรขึ้น
• มีรหัสค่าใช้จ่ายน้อยที่สุด - มันพอดีในบรรทัดเดียว
• เป็นเรื่องยากที่จะเข้าใจผิด (สามารถทิ้งไปvolatileโดยบังเอิญ แต่volatileเป็นผู้คัดเลือกที่หายาก)

หากคุณต้องการที่จะไปเส้นทางการหักเงินเต็มรูปแบบนั้นสามารถทำได้โดยมีฟังก์ชั่นผู้ช่วย

template<typename T>
constexpr T & as_mutable(T const & value) noexcept {
    return const_cast<T &>(value);
}
template<typename T>
constexpr T * as_mutable(T const * value) noexcept {
    return const_cast<T *>(value);
}
template<typename T>
constexpr T * as_mutable(T * value) noexcept {
    return value;
}
template<typename T>
void as_mutable(T const &&) = delete;

ตอนนี้คุณไม่สามารถแม้แต่จะสับสนvolatileและการใช้งานดูเหมือนว่า

decltype(auto) f() const {
    return something_complicated();
}
decltype(auto) f() {
    return as_mutable(std::as_const(*this).f());
}

ฉันคิดว่าโซลูชันของ Scott Meyers สามารถปรับปรุงได้ใน C ++ 11 โดยใช้ฟังก์ชันตัวช่วยชั่วคราว สิ่งนี้ทำให้ความตั้งใจชัดเจนมากขึ้นและสามารถนำมาใช้ซ้ำสำหรับผู้ได้รับรายอื่น ๆ

template <typename T>
struct NonConst {typedef T type;};
template <typename T>
struct NonConst<T const> {typedef T type;}; //by value
template <typename T>
struct NonConst<T const&> {typedef T& type;}; //by reference
template <typename T>
struct NonConst<T const*> {typedef T* type;}; //by pointer
template <typename T>
struct NonConst<T const&&> {typedef T&& type;}; //by rvalue-reference

template<typename TConstReturn, class TObj, typename... TArgs>
typename NonConst<TConstReturn>::type likeConstVersion(
   TObj const* obj,
   TConstReturn (TObj::* memFun)(TArgs...) const,
   TArgs&&... args) {
      return const_cast<typename NonConst<TConstReturn>::type>(
         (obj->*memFun)(std::forward<TArgs>(args)...));
}

ฟังก์ชันตัวช่วยนี้สามารถใช้วิธีต่อไปนี้

struct T {
   int arr[100];

   int const& getElement(size_t i) const{
      return arr[i];
   }

   int& getElement(size_t i) {
      return likeConstVersion(this, &T::getElement, i);
   }
};

อาร์กิวเมนต์แรกเป็นตัวชี้นี้เสมอ ประการที่สองคือตัวชี้ไปยังฟังก์ชั่นสมาชิกที่จะโทร หลังจากนั้นจำนวนอาร์กิวเมนต์เพิ่มเติมสามารถส่งผ่านได้เพื่อให้สามารถส่งต่อไปยังฟังก์ชันได้ สิ่งนี้ต้องการ C ++ 11 เนื่องจากเทมเพลต Variadic

verbose มากกว่า Meyers เล็กน้อย แต่ฉันอาจทำสิ่งนี้:

class X {

    private:

    // This method MUST NOT be called except from boilerplate accessors.
    Z &_getZ(size_t index) const {
        return something;
    }

    // boilerplate accessors
    public:
    Z &getZ(size_t index)             { return _getZ(index); }
    const Z &getZ(size_t index) const { return _getZ(index); }
};

เมธอดไพรเวตมีคุณสมบัติที่ไม่พึงประสงค์ซึ่งจะส่งคืนค่า Z ที่ไม่ใช่ const และสำหรับอินสแตนซ์ const ซึ่งเป็นสาเหตุที่ทำให้เป็นส่วนตัว วิธีการส่วนตัวอาจทำลายค่าคงที่ของอินเทอร์เฟซภายนอก (ในกรณีนี้ค่าคงที่ที่ต้องการคือ "วัตถุ const ไม่สามารถแก้ไขได้ผ่านการอ้างอิงที่ได้รับผ่านไปยังวัตถุที่มี -a")

โปรดทราบว่าความคิดเห็นเป็นส่วนหนึ่งของรูปแบบ - ส่วนติดต่อของ _getZ ระบุว่ามันไม่ถูกต้องที่จะเรียกมัน (นอกเหนือจาก accessors อย่างชัดเจน): ไม่มีประโยชน์เท่าที่จะเป็นไปได้เพราะมันเป็น 1 ตัวอักษรที่จะพิมพ์และจะไม่ ส่งผลให้รหัสมีขนาดเล็กลงหรือเร็วขึ้น การเรียกเมธอดนั้นเทียบเท่ากับการเรียกหนึ่งใน accessors ด้วย const_cast และคุณไม่ต้องการทำเช่นนั้น หากคุณกังวลเกี่ยวกับการทำข้อผิดพลาดอย่างชัดเจน (และนั่นเป็นเป้าหมายที่ยุติธรรม) ให้เรียกว่า const_cast_getZ แทน _getZ

อย่างไรก็ตามฉันขอขอบคุณทางออกของเมเยอร์ส ฉันไม่มีข้อคัดค้านทางปรัชญา แม้ว่าโดยส่วนตัวแล้วฉันชอบการทำซ้ำแบบควบคุมนิดหน่อยและวิธีการส่วนตัวที่ต้องถูกเรียกในสถานการณ์ที่ควบคุมอย่างแน่นหนาบางอย่างเท่านั้นโดยใช้วิธีที่ดูเหมือนเสียงรบกวนของสาย เลือกพิษของคุณและติดกับมัน

[แก้ไข: เควินชี้ให้เห็นอย่างถูกต้องว่า _getZ อาจต้องการเรียกใช้วิธีการเพิ่มเติม (พูดว่า generateZ) ซึ่งเป็นผู้เชี่ยวชาญเฉพาะในลักษณะเดียวกับ getZ ในกรณีนี้ _getZ จะเห็น const Z & และต้อง const_cast ก่อนกลับ มันยังคงปลอดภัยเนื่องจากทุกอย่างของอุปกรณ์ควบคุมความร้อน แต่มันไม่ชัดเจนว่าปลอดภัย นอกจากนี้ถ้าคุณทำอย่างนั้นแล้วเปลี่ยน generateZ ให้คืนค่า const เสมอคุณก็ต้องเปลี่ยน getZ ให้คืนค่า const เสมอ แต่คอมไพเลอร์จะไม่บอกคุณว่าคุณทำ

จุดหลังนั้นเกี่ยวกับคอมไพเลอร์ก็เป็นจริงตามรูปแบบที่แนะนำของ Meyers แต่จุดแรกเกี่ยวกับ const_cast ที่ไม่ชัดเจนนั้นไม่ใช่ ด้วยความสมดุลฉันคิดว่าถ้า _getZ กลายเป็นต้องการค่า const_cast สำหรับค่าส่งคืนรูปแบบนี้จะสูญเสียมูลค่าของมันมากกว่า Meyers เนื่องจากมันยังมีความเสียเปรียบเมื่อเทียบกับของเมเยอร์ฉันคิดว่าฉันจะเปลี่ยนไปใช้สถานการณ์ของเขา การปรับโครงสร้างจากที่หนึ่งไปอีกที่หนึ่งนั้นง่ายดาย - มันไม่ส่งผลกระทบต่อรหัสที่ถูกต้องอื่น ๆ ในชั้นเรียนเนื่องจากมีเพียงรหัสที่ไม่ถูกต้องเท่านั้น

คำถามที่ดีและคำตอบที่ดี ฉันมีวิธีแก้ไขปัญหาอื่นที่ไม่มีการปลดเปลื้อง:

class X {

private:

    std::vector<Z> v;

    template<typename InstanceType>
    static auto get(InstanceType& instance, std::size_t i) -> decltype(instance.get(i)) {
        // massive amounts of code for validating index
        // the instance variable has to be used to access class members
        return instance.v[i];
    }

public:

    const Z& get(std::size_t i) const {
        return get(*this, i);
    }

    Z& get(std::size_t i) {
        return get(*this, i);
    }

};

อย่างไรก็ตามมีความน่าเกลียดที่ต้องมีสมาชิกแบบสแตติกและความต้องการในการใช้ instanceตัวแปรภายใน

ฉันไม่ได้พิจารณาถึงผลกระทบ (เชิงลบ) ที่เป็นไปได้ทั้งหมดของการแก้ปัญหานี้ โปรดแจ้งให้เราทราบหากมี

คุณสามารถแก้ไขได้ด้วยเทมเพลต วิธีการแก้ปัญหานี้น่าเกลียดเล็กน้อย (แต่ความอัปลักษณ์ถูกซ่อนอยู่ในไฟล์. cpp) แต่ให้การตรวจสอบคอมไพเลอร์ของ constness และไม่มีการทำซ้ำรหัส

ไฟล์. h:

#include <vector>

class Z
{
    // details
};

class X
{
    std::vector<Z> vecZ;

public:
    const std::vector<Z>& GetVector() const { return vecZ; }
    std::vector<Z>& GetVector() { return vecZ; }

    Z& GetZ( size_t index );
    const Z& GetZ( size_t index ) const;
};

ไฟล์. cpp:

#include "constnonconst.h"

template< class ParentPtr, class Child >
Child& GetZImpl( ParentPtr parent, size_t index )
{
    // ... massive amounts of code ...

    // Note you may only use methods of X here that are
    // available in both const and non-const varieties.

    Child& ret = parent->GetVector()[index];

    // ... even more code ...

    return ret;
}

Z& X::GetZ( size_t index )
{
    return GetZImpl< X*, Z >( this, index );
}

const Z& X::GetZ( size_t index ) const
{
    return GetZImpl< const X*, const Z >( this, index );
}

ข้อเสียเปรียบหลักที่ฉันเห็นคือเนื่องจากการใช้วิธีการที่ซับซ้อนทั้งหมดอยู่ในฟังก์ชั่นระดับโลกคุณต้องได้รับสมาชิกของ X โดยใช้วิธีสาธารณะเช่น GetVector () ด้านบน (ซึ่งต้องมีเสมอ รุ่น const และไม่ใช่ const) หรือคุณอาจทำให้ฟังก์ชั่นนี้เป็นเพื่อนได้ แต่ฉันไม่ชอบเพื่อน

[แก้ไข: ลบรวม cstdio ที่ไม่จำเป็นออกระหว่างการทดสอบ]

วิธีการเกี่ยวกับการย้ายตรรกะเป็นวิธีส่วนตัวและเพียงทำ "รับการอ้างอิงและส่งคืน" สิ่งภายใน getters? ที่จริงแล้วฉันค่อนข้างสับสนเกี่ยวกับสแตติกและตัวละครในฟังก์ชัน getter ที่เรียบง่ายและฉันคิดว่าน่าเกลียดยกเว้นสถานการณ์ที่หายากมาก!

มันโกงที่จะใช้ตัวประมวลผลล่วงหน้าหรือไม่?

struct A {

    #define GETTER_CORE_CODE       \
    /* line 1 of getter code */    \
    /* line 2 of getter code */    \
    /* .....etc............. */    \
    /* line n of getter code */       

    // ^ NOTE: line continuation char '\' on all lines but the last

   B& get() {
        GETTER_CORE_CODE
   }

   const B& get() const {
        GETTER_CORE_CODE
   }

   #undef GETTER_CORE_CODE

};

มันไม่ได้สวยเหมือนเทมเพลตหรือการร่าย แต่มันทำให้ความตั้งใจของคุณ ("ฟังก์ชั่นทั้งสองนี้เหมือนกัน") ค่อนข้างชัดเจน

เป็นเรื่องที่น่าแปลกใจสำหรับฉันที่มีคำตอบที่แตกต่างกันมากมาย แต่เกือบทั้งหมดล้วนพึ่งพาเวทมนตร์แม่แบบ เทมเพลตนั้นทรงพลัง แต่บางครั้งแมโครก็ใช้งานได้อย่างกระชับ ความเก่งกาจสูงสุดมักจะทำได้โดยการรวมทั้งสองอย่างเข้าด้วยกัน

ฉันเขียนมาโคร FROM_CONST_OVERLOAD()ซึ่งสามารถวางในฟังก์ชันที่ไม่ใช่ const เพื่อเรียกใช้ฟังก์ชัน const

ตัวอย่างการใช้งาน:

class MyClass
{
private:
    std::vector<std::string> data = {"str", "x"};

public:
    // Works for references
    const std::string& GetRef(std::size_t index) const
    {
        return data[index];
    }

    std::string& GetRef(std::size_t index)
    {
        return FROM_CONST_OVERLOAD( GetRef(index) );
    }


    // Works for pointers
    const std::string* GetPtr(std::size_t index) const
    {
        return &data[index];
    }

    std::string* GetPtr(std::size_t index)
    {
        return FROM_CONST_OVERLOAD( GetPtr(index) );
    }
};

ใช้งานง่ายและนำมาใช้ใหม่:

template <typename T>
T& WithoutConst(const T& ref)
{
    return const_cast<T&>(ref);
}

template <typename T>
T* WithoutConst(const T* ptr)
{
    return const_cast<T*>(ptr);
}

template <typename T>
const T* WithConst(T* ptr)
{
    return ptr;
}

#define FROM_CONST_OVERLOAD(FunctionCall) \
  WithoutConst(WithConst(this)->FunctionCall)

คำอธิบาย:

ตามที่โพสต์ในคำตอบมากมายรูปแบบทั่วไปเพื่อหลีกเลี่ยงการทำซ้ำรหัสในฟังก์ชั่นสมาชิกที่ไม่ใช่สมาชิกคือ:

return const_cast<Result&>( static_cast<const MyClass*>(this)->Method(args) );

หม้อต้มน้ำจำนวนมากสามารถหลีกเลี่ยงได้โดยใช้การอนุมานประเภท ก่อนอื่นconst_castสามารถห่อหุ้มWithoutConst()ซึ่ง infers ประเภทของการโต้แย้งและลบ const-qualifier ประการที่สองวิธีการที่คล้ายกันสามารถใช้ในWithConst()การ const- คัดเลือกthisตัวชี้ซึ่งช่วยให้การเรียกวิธีการ const-overloaded

ส่วนที่เหลือเป็นแมโครอย่างง่ายที่นำหน้าการโทรด้วยคุณสมบัติที่ถูกต้องthis->และลบ const จากผลลัพธ์ เนื่องจากนิพจน์ที่ใช้ในแมโครนั้นมักจะเป็นการเรียกใช้ฟังก์ชั่นแบบง่าย ๆ โดยมีอาร์กิวเมนต์ที่ส่งต่อ 1: 1 ข้อเสียของมาโครเช่นการประเมินหลาย ๆ ครั้งจึงไม่เริ่มขึ้น__VA_ARGS__ยังสามารถใช้งานได้ ตัวแยกอาร์กิวเมนต์) เกิดขึ้นภายในวงเล็บ

วิธีนี้มีประโยชน์หลายประการ:

• ไวยากรณ์น้อยที่สุดและเป็นธรรมชาติ - เพียงแค่วางสาย FROM_CONST_OVERLOAD( )
• ไม่จำเป็นต้องใช้ฟังก์ชั่นพิเศษของสมาชิก
• เข้ากันได้กับ C ++ 98
• ใช้งานง่ายไม่มี metaprogramming แม่แบบและการอ้างอิงเป็นศูนย์
• Extensible: ความสัมพันธ์ระหว่าง const อื่น ๆ สามารถเพิ่ม (เช่นconst_iterator, std::shared_ptr<const T>ฯลฯ ) สำหรับเรื่องนี้เพียงแค่โอเวอร์โหลดWithoutConst()สำหรับประเภทที่เกี่ยวข้อง

ข้อ จำกัด : โซลูชันนี้ได้รับการปรับให้เหมาะสมที่สุดสำหรับสถานการณ์ที่การโอเวอร์โหลดที่ไม่ใช่ const ดำเนินการตรงกับ const โอเวอร์โหลดดังนั้นอาร์กิวเมนต์สามารถส่งต่อได้ 1: 1 หากตรรกะของคุณแตกต่างและคุณไม่ได้เรียกเวอร์ชัน const ผ่านthis->Method(args)คุณอาจพิจารณาแนวทางอื่น ๆ

สำหรับผู้ที่ (เช่นฉัน) ที่

• ใช้c ++ 17
• ต้องการเพิ่มจำนวนแผ่นอย่างน้อย / การทำซ้ำและ
• ไม่ต้องกังวลกับการใช้มาโคร (ในขณะที่รอเมตาคลาส ... )

นี่คืออีกหนึ่ง:

#include <utility>
#include <type_traits>

template <typename T> struct NonConst;
template <typename T> struct NonConst<T const&> {using type = T&;};
template <typename T> struct NonConst<T const*> {using type = T*;};

#define NON_CONST(func)                                                     \
    template <typename... T> auto func(T&&... a)                            \
        -> typename NonConst<decltype(func(std::forward<T>(a)...))>::type   \
    {                                                                       \
        return const_cast<decltype(func(std::forward<T>(a)...))>(           \
            std::as_const(*this).func(std::forward<T>(a)...));              \
    }

มันเป็นการผสมผสานระหว่างคำตอบจาก @Pait, @DavidStone และ @ sh1 ( แก้ไข : และปรับปรุงจาก @cdhowie) สิ่งที่เพิ่มลงในตารางคือคุณจะได้รับโค้ดพิเศษอีกหนึ่งบรรทัดซึ่งจะตั้งชื่อฟังก์ชั่น (แต่ไม่มีอาร์กิวเมนต์หรือการทำซ้ำชนิดส่งคืน):

class X
{
    const Z& get(size_t index) const { ... }
    NON_CONST(get)
};

หมายเหตุ: gcc ล้มเหลวในการรวบรวมสิ่งนี้ก่อนหน้า 8.1, เสียงดังกราว -5 ขึ้นไปและ MSVC-19 มีความสุข (อ้างอิงจากคอมไพเลอร์ explorer )

นี่คือฟังก์ชันตัวช่วยคงที่แม่แบบรุ่น C ++ 17 พร้อมด้วยและการทดสอบเสริม SFINAE

#include <type_traits>

#define REQUIRES(...)         class = std::enable_if_t<(__VA_ARGS__)>
#define REQUIRES_CV_OF(A,B)   REQUIRES( std::is_same_v< std::remove_cv_t< A >, B > )

class Foobar {
private:
    int something;

    template<class FOOBAR, REQUIRES_CV_OF(FOOBAR, Foobar)>
    static auto& _getSomething(FOOBAR& self, int index) {
        // big, non-trivial chunk of code...
        return self.something;
    }

public:
    auto& getSomething(int index)       { return _getSomething(*this, index); }
    auto& getSomething(int index) const { return _getSomething(*this, index); }
};

เวอร์ชันเต็ม: https://godbolt.org/z/mMK4r3

ฉันสร้างแมโครขึ้นมาเพื่อสร้างฟังก์ชั่น const / ไม่ใช่ const โดยอัตโนมัติ

class A
{
    int x;    
  public:
    MAYBE_CONST(
        CV int &GetX() CV {return x;}
        CV int &GetY() CV {return y;}
    )

    //   Equivalent to:
    // int &GetX() {return x;}
    // int &GetY() {return y;}
    // const int &GetX() const {return x;}
    // const int &GetY() const {return y;}
};

ดูจุดสิ้นสุดของคำตอบสำหรับการนำไปใช้

อาร์กิวเมนต์ของMAYBE_CONSTซ้ำซ้อน ในสำเนาแรกCVจะถูกแทนที่ด้วยไม่มีอะไร constและสำเนาที่สองก็ถูกแทนที่ด้วย

ไม่มีการ จำกัด จำนวนครั้งที่CVสามารถปรากฏในอาร์กิวเมนต์แมโคร

แม้ว่าจะมีความไม่สะดวกเล็กน้อย หากCVปรากฏอยู่ในวงเล็บวงเล็บจะต้องนำหน้าด้วยCV_IN:

// Doesn't work
MAYBE_CONST( CV int &foo(CV int &); )

// Works, expands to
//         int &foo(      int &);
//   const int &foo(const int &);
MAYBE_CONST( CV int &foo CV_IN(CV int &); )

การดำเนินงาน:

#define MAYBE_CONST(...) IMPL_CV_maybe_const( (IMPL_CV_null,__VA_ARGS__)() )
#define CV )(IMPL_CV_identity,
#define CV_IN(...) )(IMPL_CV_p_open,)(IMPL_CV_null,__VA_ARGS__)(IMPL_CV_p_close,)(IMPL_CV_null,

#define IMPL_CV_null(...)
#define IMPL_CV_identity(...) __VA_ARGS__
#define IMPL_CV_p_open(...) (
#define IMPL_CV_p_close(...) )

#define IMPL_CV_maybe_const(seq) IMPL_CV_a seq IMPL_CV_const_a seq

#define IMPL_CV_body(cv, m, ...) m(cv) __VA_ARGS__

#define IMPL_CV_a(...) __VA_OPT__(IMPL_CV_body(,__VA_ARGS__) IMPL_CV_b)
#define IMPL_CV_b(...) __VA_OPT__(IMPL_CV_body(,__VA_ARGS__) IMPL_CV_a)

#define IMPL_CV_const_a(...) __VA_OPT__(IMPL_CV_body(const,__VA_ARGS__) IMPL_CV_const_b)
#define IMPL_CV_const_b(...) __VA_OPT__(IMPL_CV_body(const,__VA_ARGS__) IMPL_CV_const_a)

การใช้งานล่วงหน้า C ++ 20 ที่ไม่รองรับCV_IN:

#define MAYBE_CONST(...) IMPL_MC( ((__VA_ARGS__)) )
#define CV ))((

#define IMPL_MC(seq) \
    IMPL_MC_end(IMPL_MC_a seq) \
    IMPL_MC_end(IMPL_MC_const_0 seq)

#define IMPL_MC_identity(...) __VA_ARGS__
#define IMPL_MC_end(...) IMPL_MC_end_(__VA_ARGS__)
#define IMPL_MC_end_(...) __VA_ARGS__##_end

#define IMPL_MC_a(elem) IMPL_MC_identity elem IMPL_MC_b
#define IMPL_MC_b(elem) IMPL_MC_identity elem IMPL_MC_a
#define IMPL_MC_a_end
#define IMPL_MC_b_end

#define IMPL_MC_const_0(elem)       IMPL_MC_identity elem IMPL_MC_const_a
#define IMPL_MC_const_a(elem) const IMPL_MC_identity elem IMPL_MC_const_b
#define IMPL_MC_const_b(elem) const IMPL_MC_identity elem IMPL_MC_const_a
#define IMPL_MC_const_a_end
#define IMPL_MC_const_b_end

โดยทั่วไปฟังก์ชั่นสมาชิกที่คุณต้องการรุ่น const และไม่ใช่ const คือ getters และ setters ส่วนใหญ่เวลาพวกเขาเป็นหนึ่ง liners ดังนั้นการทำสำเนารหัสไม่ใช่ปัญหา

ฉันทำสิ่งนี้กับเพื่อนที่ชอบธรรมอย่างชอบธรรมในการใช้const_cast... โดยไม่รู้ว่าฉันอาจทำอะไรแบบนี้ (ไม่หรูหราจริงๆ):

#include <iostream>

class MyClass
{

public:

    int getI()
    {
        std::cout << "non-const getter" << std::endl;
        return privateGetI<MyClass, int>(*this);
    }

    const int getI() const
    {
        std::cout << "const getter" << std::endl;
        return privateGetI<const MyClass, const int>(*this);
    }

private:

    template <class C, typename T>
    static T privateGetI(C c)
    {
        //do my stuff
        return c._i;
    }

    int _i;
};

int main()
{
    const MyClass myConstClass = MyClass();
    myConstClass.getI();

    MyClass myNonConstClass;
    myNonConstClass.getI();

    return 0;
}

ฉันขอแนะนำแม่แบบฟังก์ชั่นคงผู้ช่วยส่วนตัวเช่นนี้

class X
{
    std::vector<Z> vecZ;

    // ReturnType is explicitly 'Z&' or 'const Z&'
    // ThisType is deduced to be 'X' or 'const X'
    template <typename ReturnType, typename ThisType>
    static ReturnType Z_impl(ThisType& self, size_t index)
    {
        // massive amounts of code for validating index
        ReturnType ret = self.vecZ[index];
        // even more code for determining, blah, blah...
        return ret;
    }

public:
    Z& Z(size_t index)
    {
        return Z_impl<Z&>(*this, index);
    }
    const Z& Z(size_t index) const
    {
        return Z_impl<const Z&>(*this, index);
    }
};

บทความ DDJ นี้แสดงวิธีการใช้เทมเพลตเฉพาะทางที่ไม่ต้องการให้คุณใช้ const_cast สำหรับฟังก์ชั่นที่เรียบง่ายมันไม่จำเป็นจริงๆ

เพิ่ม :: any_cast (ณ จุดหนึ่งมันไม่ได้อีกแล้ว) ใช้ const_cast จากรุ่น const เรียกรุ่นที่ไม่ใช่ const เพื่อหลีกเลี่ยงการทำซ้ำ คุณไม่สามารถกำหนดความหมายของ const ในเวอร์ชันที่ไม่ใช่ const ได้ดังนั้นคุณต้องเป็นอย่างมากระมัดระวังกับว่า

ในที่สุดการทำสำเนารหัสก็ไม่เป็นไรตราบใดที่ข้อมูลโค้ดทั้งสองนั้นวางซ้อนกันโดยตรง

หากต้องการเพิ่มโซลูชัน jwfearn และ kevin ที่ให้มานี่คือโซลูชันที่สอดคล้องกันเมื่อฟังก์ชันส่งคืน shared_ptr:

struct C {
  shared_ptr<const char> get() const {
    return c;
  }
  shared_ptr<char> get() {
    return const_pointer_cast<char>(static_cast<const C &>(*this).get());
  }
  shared_ptr<char> c;
};

ไม่พบสิ่งที่ฉันกำลังมองหาดังนั้นฉันจึงรีดเป็นของตัวเอง ...

อันนี้เป็นคำเล็กน้อย แต่มีประโยชน์ในการจัดการวิธีการโอเวอร์โหลดจำนวนมากในชื่อเดียวกัน (และประเภทผลตอบแทน) ทั้งหมดในครั้งเดียว:

struct C {
  int x[10];

  int const* getp() const { return x; }
  int const* getp(int i) const { return &x[i]; }
  int const* getp(int* p) const { return &x[*p]; }

  int const& getr() const { return x[0]; }
  int const& getr(int i) const { return x[i]; }
  int const& getr(int* p) const { return x[*p]; }

  template<typename... Ts>
  auto* getp(Ts... args) {
    auto const* p = this;
    return const_cast<int*>(p->getp(args...));
  }

  template<typename... Ts>
  auto& getr(Ts... args) {
    auto const* p = this;
    return const_cast<int&>(p->getr(args...));
  }
};

หากคุณมีเพียงหนึ่งconstวิธีต่อชื่อ แต่ยังมีวิธีการทำซ้ำมากมายคุณอาจต้องการสิ่งนี้:

  template<typename T, typename... Ts>
  auto* pwrap(T const* (C::*f)(Ts...) const, Ts... args) {
    return const_cast<T*>((this->*f)(args...));
  }

  int* getp_i(int i) { return pwrap(&C::getp_i, i); }
  int* getp_p(int* p) { return pwrap(&C::getp_p, p); }

น่าเสียดายที่สิ่งนี้พังลงทันทีที่คุณเริ่มโหลดชื่อมากเกินไป (รายการอาร์กิวเมนต์ของตัวชี้ฟังก์ชั่นอาร์กิวเมนต์ของตัวชี้ฟังก์ชั่นดูเหมือนจะไม่ได้รับการแก้ไข ณ จุดนั้นดังนั้นจึงไม่พบการจับคู่สำหรับอาร์กิวเมนต์ของฟังก์ชัน) แม้ว่าคุณจะสามารถเทมเพลตของคุณได้เช่นกัน:

  template<typename... Ts>
  auto* getp(Ts... args) { return pwrap<int, Ts...>(&C::getp, args...); }

แต่ข้อโต้แย้งการอ้างอิงถึงconstวิธีการล้มเหลวในการจับคู่กับข้อโต้แย้งโดยค่าที่เห็นได้ชัดกับแม่แบบและมันจะแบ่ง ไม่แน่ใจว่าทำไม นี่คือเหตุผลที่