函數參數分組和常量

Question

我們試圖重構我們的代碼，我們想要的改進之一如下：許多函數有許多參數，但其中很多參數共享一個公共子集。所以，我們想創建一個可以將它們分組的結構。問題是一些函數需要一些參數爲const，有些則不是。其中一些函數必須能夠調用提供此參數分組結構的這些函數的子集，但是在以下限制下：被調用函數不能「降級」此結構的常量（請參見下面的示例）。實現此結構的所有必需變體解決了這個問題，但並不優雅。我們正在努力解決辦法之一是使用模板，e.g：

template<class A, class B, class C> 
struct my_container 
{ 
    A a; 
    B b; 
    C c; 
}; 

void foo1(my_container<int, char, float const> & my_cont) 
{ 
} 

void foo2(my_container<int const, char, float const> & my_cont) 
{ 
    // This should NOT be allowed: we do mind something being const to be treated by the 
    // called function as non-const. 
    foo1(my_cont); 
} 

void foo3(my_container<int, char, float> & my_cont) 
{ 
    // This should be allowed: we don't mind something being non-const to be treated by the 
    // called function as const. 
    foo2(my_cont); 
} 

我們的問題是，foo2的要求foo1沒有編譯器抱怨，和我們想的完全相反。這甚至可以用模板來實現嗎？還有其他技術嗎？

Answer 1

我的解決方案有點元編程。看起來很醜陋，而不是throughoutly測試，但不管怎麼說： 這樣，一切都應該在一般的工作「開箱即用」

#include <iostream> 
#include <boost/type_traits.hpp> 

template<class A, class B, class C> 
struct my_container 
{ 
    A a; 
    B b; 
    C c; 

    template<typename An, typename Bn, typename Cn> 
    operator my_container<An,Bn,Cn>&() 
    { 
     /* First, check whether compatible at all */ 
     BOOST_STATIC_ASSERT((boost::is_same<typename boost::remove_cv<A>::type, typename boost::remove_cv<An>::type>::value)); 
     BOOST_STATIC_ASSERT((boost::is_same<typename boost::remove_cv<B>::type, typename boost::remove_cv<Bn>::type>::value)); 
     BOOST_STATIC_ASSERT((boost::is_same<typename boost::remove_cv<C>::type, typename boost::remove_cv<Cn>::type>::value)); 
     /* Enforce const'ness */ 
     BOOST_STATIC_ASSERT(!boost::is_const<A>::value || boost::is_const<An>::value); 
     BOOST_STATIC_ASSERT(!boost::is_const<B>::value || boost::is_const<Bn>::value); 
     BOOST_STATIC_ASSERT(!boost::is_const<C>::value || boost::is_const<Cn>::value); 

     return *reinterpret_cast< my_container<An,Bn,Cn>* >(this); 
    } 
}; 

void foo1(my_container<int, char, float const> & my_cont) 
{ 
} 

void foo2(my_container<int const, char, float const> & my_cont) 
{ 
    // This should NOT be allowed: we do mind something being const to be treated by the 
    // called function as non-const. 
    //foo1(my_cont); /// BOOST_STATIC_ASSERT fails! Hurray! 
} 

void foo3(my_container<int, char, float> & my_cont) 
{ 
    // This should be allowed: we don't mind something being non-const to be treated by the 
    // called function as const. 
    foo2(my_cont); /// No complaints! Hurray! 
} 

int main(int argc, char* argv[]) 
{ 
    my_container<int,char,float> foobar; 

    foo3(foobar); 

    return 0; 
} 

Answer 2

都不應該工作。模板的不同實例是未經過處理的類型，它們之間沒有隱式轉換。所以 my_container<int, char, float const>,my_container<int const, char, float const>和my_container<int, char, float>都是不相關的 類型，它們之間沒有隱式轉換。

應該可以制定出使用繼承的東西，使用 元編程技巧，以確定你繼承了什麼，但我不 知道如何，我懷疑，這將是更多的努力比它的價值。

Answer 3

不接壤未定義行爲，這可以通過間接的另一個層面上實現。添加引用原始成員的視圖類。可以隱式添加Constness，但不能刪除。

template<class A, class B, class C> 
struct my_container 
{ 
    A a; 
    B b; 
    C c; 
}; 

template <class A, class B, class C> 
class my_container_view 
{ 
    A* a_; 
    B* b_; 
    C* c_; 

public: 
    template <class A_, class B_, class C_> 
    my_container_view(my_container<A_, B_, C_>& source): 
     a_(&source.a), b_(&source.b), c_(&source.c) 
    {} 
    template <class A_, class B_, class C_> 
    my_container_view(my_container_view<A_, B_, C_>& source): 
     a_(&source.a()), b_(&source.b()), c_(&source.c()) 
    {} 
    A& a() const { return *a_; } 
    B& b() const { return *b_; } 
    C& c() const { return *c_; } 
}; 

void foo1(my_container_view<int, char, float const> my_cont) 
{ 
    my_cont.a() = 10; 
    my_cont.b() = 'a'; 
    my_cont.c() /*= 3.14*/; 
} 

void foo2(my_container_view<int const, char, float const> my_cont) 
{ 
    my_cont.a() /*= 10*/; 
    my_cont.b() = 'a'; 
    my_cont.c() /*= 3.14*/; 

    //foo1(my_cont); //not allowed 
} 

void foo3(my_container_view<int, char, float> my_cont) 
{ 
    my_cont.a() = 10; 
    my_cont.b() = 'a'; 
    my_cont.c() = 3.14; 
t 
    foo2(my_cont); 
} 

int main() 
{ 
    my_container<int, char, float> mc; 
    foo1(mc); 
    foo2(mc); 
    foo3(mc); 
} 

（我有我的懷疑，不過，這多少是值得通常帶班，要麼你可以修改它的所有成員 - 你只是不修改你不想要的那些 - ，或者你不能修改任何，如果你想要這個級別的控制，你寧願單獨傳遞每個參數 - 與你正在做的事情相反）。