聲明靜態函數爲朋友函數？

Question

我在file1.cpp的頭文件interface.h和一些靜態函數（foo和bar和幾個更多）中有一個類MyClass聲明。靜態函數僅用於file1.cpp之內，但它們需要修改MyClass的私有/受保護成員。

// in "interface.h" 
class MyClass { 
// maybe declare as friend? 
// friend static void foo(MyClass &ref); 
private: 
    double someval; 
} 

// in "file1.cpp" 
static void foo(MyClass &ref) { 
    ref.someval = 41.0; 
} 
static void bar(MyClass &ref) { 
    ref.someval = 0.42; 
} 

// function that uses foo/bar 
void doSomething(MyClass &ref) { 
    foo(ref);   
} 

理念1：不知何故聲明它們爲MyClass朋友？

爲什麼它不好：它們是靜態的，在不同的編譯單元中。除此之外，他們會將他們暴露給MyClass的用戶，他們不需要知道任何關於他們的信息。

理念2：不要有想法2.

排序鏈接：Is it possible to declare a friend function as static?

Answer 1

排序的鏈接：是否有可能聲明友元函數靜態？

我個人覺得整個事情friend有點打破封裝一個黑客攻擊，但你問了一個有效的問題，答案是，你可以達到你想要一個幫手類什麼：

file1.h

class MyClass { 
private: 
    double someval; 

    friend class MyClassHelper; 
}; 

file1.cpp

#include "file1.h" 


struct MyClassHelper { 
    static void mutateMyClass(MyClass& ref) { 
    ref.someval=42; 
    } 
}; 


// in "file1.cpp" 
static void foo(MyClass &ref) { 
    MyClassHelper::mutateMyClass(ref); 
} 

你真的確定要這樣做嗎？你確定你不想在MyClass中封裝MyClass的增變器嗎？

Answer 2

聽起來很奇怪（而且看起來），你實際上可以閱讀&編寫類/結構的私有成員。

這並不漂亮，當然也不鼓勵，但可行。

template<typename T> 
struct invisible 
{ 
    static typename T::type value; 
}; 

template<typename T> 
typename T::type invisible<T>::value; 

template<typename T, typename T::type P> 
class construct_invisible 
{ 
    construct_invisible(){ invisible<T>::value = P; } 
    static const construct_invisible instance; 
}; 

template<typename T, typename T::type P> 
const construct_invisible<T, P> construct_invisible<T, P>::instance; 

struct MyClass_someval{ typedef double MyClass::*type; }; 
template class construct_invisible<MyClass_someval, &MyClass::someval>; 

static void foo(MyClass &ref) { 
    ref.*invisible<MyClass_someval>::value = 41.0; 
} 

當我第一次看到它時，我也想過：HOLY S ***！

Answer 3

// in "interface.h" 
class MyClass { 
    // maybe declare as friend? 
    // friend static void foo(MyClass &ref); 
public: 

    friend class SetSomevalClass; // make the classes friends 

private: 

    double someval; 
}; 

class SetSomevalClass // functor class(or function class) 
{ 
public: 
    double operator()(MyClass n, double data) // this could have been void 
    { 
    n.someval = data; //set somevalue to data 
    return n.someval; //return somevalue 
    // return is solely used to show result in foo() and bar() 
    } 
}; 


// in "file1.cpp" 
static void foo(MyClass &ref) 
{ 
    SetSomevalClass s; //create functor object 

    //s(ref, 40); 
    //this would be the end of the foo function(uncommented) if we did  not want to show the result 

    std::cout << "foo()" << s(ref, 40) << std::endl; 
    //simply to show result 

} 
static void bar(MyClass &ref) 
{ 
    SetSomevalClass s; 

    //s(ref,2); 

    //this would be the end of the foo function(uncommented) if we did not want to show the result 

    std::cout << "bar()" << s(ref, 2) << std::endl; 
} 

// function that uses foo/bar 
void doSomething(MyClass &ref) //calls both foo() and bar() 
{ 
    foo(ref); 
    bar(ref); 

} 

int main() 
{ 
    MyClass s; 
    doSomething(s); 
}// end main