मैं एक सामान्य फ़ंक्शन का उपयोग करके एक स्विफ्ट क्लास पर एक स्थिर विधि को कॉल करने का प्रयास कर रहा हूं, इसलिए मुझे फ़ंक्शन हस्ताक्षर का हिस्सा बनने के लिए वास्तव में कक्षा के प्रकार की आवश्यकता नहीं है।
ऐसा करने का कोई तरीका नहीं दिख रहा है।

मैं जो करने की कोशिश कर रहा हूं उसका एक सी ++ नमूना यहां दिया गया है:

#include <iostream>

class A {
public:
    static void f(){
        std::cout << "A::f()" << std::endl;
    }
};

class B {
public:
    static void f(){
        std::cout << "B::f()" << std::endl;
    }
};

template <typename T>
void callF(){
    T::f();
}

int main(){
    callF<A>();
    callF<B>();
    return 0;
}

यहां मैं callF के लिए स्पष्ट विशेषज्ञता का उपयोग करता हूं जिस प्रकार की मुझे आवश्यकता है।
मुझे एहसास है कि स्विफ्ट के जेनरिक टेम्प्लेट नहीं हैं, और मैं बस कुछ भी कॉल नहीं कर सकता जो मैं चाहता हूं और अगर यह मान्य नहीं है तो कंपाइलर को तोड़ने दें, इसलिए मैंने एक प्रोटोकॉल जोड़ा और जेनेरिक पैरामीटर को प्रोटोकॉल के अनुरूप बनाने की आवश्यकता है (P में निम्नलिखित उदाहरण) लेकिन मुझे संकलक को यह बताने का कोई तरीका नहीं मिल रहा है कि मैं इसे फ़ंक्शन के हस्ताक्षर में शामिल किए बिना एक निश्चित प्रकार का उपयोग करना चाहता हूं।
यह सबसे साफ तरीका है जिसके साथ मैं आया हूं:

protocol P{
    static func f();
}

class A : P {
    static func f(){
        print("A.f()")
    }
}

class B : P {
    static func f(){
        print("B.f()")
    }
}

func callF<T:P>() -> T? {
    T.f()
    return nil
}

let _:A? = callF()
let _:B? = callF()

मैं वास्तव में अपने कोड में डमी का उपयोग करना पसंद नहीं करता, लेकिन मैं इसके आसपास काम नहीं कर सकता।
फ़ंक्शन हस्ताक्षर में डमी का उपयोग करने से बचने के बारे में कोई विचार और तेजी से पता लगाना है कि मैं किस प्रकार का उपयोग करना चाहता हूं? मैंने स्पष्ट रूप से callF<A>() की कोशिश की और पाया: त्रुटि: स्पष्ट रूप से एक सामान्य कार्य का विशेषज्ञ नहीं हो सकता

0
Moshe Gottlieb 2 नवम्बर 2018, 17:35

1 उत्तर

सबसे बढ़िया उत्तर

आपको उस प्रकार को पास करना चाहिए जिसे आप चाहते हैं कि f() को callF फ़ंक्शन में इनपुट तर्क के रूप में बुलाया जाए।

func callF<T:P>(on type:T.Type) {
    type.f()
}

callF(on: A.self) // A.f()
callF(on: B.self) // B.f()
1
Dávid Pásztor 2 नवम्बर 2018, 14:41