सी ++ में प्रारंभिक (स्थैतिक) और देर से (गतिशील) बाध्यकारी क्या है?

Question

प्रारंभिक और देर से बाइंडिंग सी ++ में कैसा दिखता है? क्या आप उदाहरण दे सकते हैं?

मैंने पढ़ा कि फ़ंक्शन ओवरलोडिंग प्रारंभिक बाध्यकारी है और वर्चुअल फ़ंक्शन देर से बाध्यकारी है। I read कि "प्रारंभिक (या स्थिर) बाध्यकारी समय बाध्यकारी और देर से (या गतिशील) बाध्यकारी संकलन को संदर्भित करता है रनटाइम बाध्यकारी को संदर्भित करता है"।

Answer 1

आप सही पढ़ते हैं।

using FuncType = int(*)(int,int); // pointer to a function 
            // taking 2 ints and returning one. 

int add(int a, int b) { return a + b; } 
int substract(int a, int b) { return a - b; } 

स्टेटिक बाध्यकारी है जब बंधन संकलन समय पर जाना जाता है: बुनियादी उदाहरण के साथ दिया जा सकता है

int main() { 
    std::cout << add(4, 5) << "\n"; 
} 

आपरेशन के एक गतिशील परिवर्तन के लिए कोई जगह छोड़ देता है, और इस तरह स्थिर बाध्य है।

int main() { 
    char op = 0; 
    std::cin >> op; 

    FuncType const function = op == '+' ? &add : &substract; 

    std::cout << function(4, 5) << "\n"; 
} 

जबकि यहां इनपुट के आधार पर, 9 या -1 हो जाता है। यह गतिशील रूप से बाध्य है।

इसके अलावा, ऑब्जेक्ट उन्मुख भाषाओं में, virtual कार्यों को गतिशील रूप से कुछ बांधने के लिए उपयोग किया जा सकता है। एक और अधिक वर्बोज़ उदाहरण इस प्रकार हो सकता है:

struct Function { 
    virtual ~Function() {} 
    virtual int doit(int, int) const = 0; 
}; 
struct Add: Function { 
    virtual int doit(int a, int b) const override { return a + b; } 
}; 
struct Substract: Function { 
    virtual int doit(int a, int b) const override { return a - b; } 
}; 

int main() { 
    char op = 0; 
    std::cin >> op; 

    std::unique_ptr<Function> func = 
     op == '+' ? std::unique_ptr<Function>{new Add{}} 
        : std::unique_ptr<Function>{new Substract{}}; 

    std::cout << func->doit(4, 5) << "\n"; 
} 

जो शब्दार्थ पिछले उदाहरण के बराबर है ... लेकिन देर virtual समारोह जो ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में आम है से बाध्यकारी परिचय देता है।

Answer 2

ये सभी ऑब्जेक्ट उन्मुख भाषाओं के बारे में सच हैं, केवल सी ++ नहीं।

स्टेटिक, संकलन समय बाध्यकारी आसान है। इसमें कोई बहुरूपता शामिल नहीं है। जब आप लिखते हैं और संकलित करते हैं और कोड चलाते हैं तो आप ऑब्जेक्ट के प्रकार को जानते हैं। कभी-कभी कुत्ता सिर्फ एक कुत्ता है।

गतिशील, रनटाइम बाइंडिंग वह जगह है जहां बहुरूपता आती है।

यदि आपके पास संकलन प्रकार पर मूल प्रकार का संदर्भ है, तो आप इसे रनटाइम पर एक बच्चे का प्रकार असाइन कर सकते हैं। संदर्भ का व्यवहार जादुई रूप से रनटाइम पर उपयुक्त प्रकार में बदल जाएगा। रनटाइम को गतिशील प्रकार क्या है, यह जानने के लिए वर्चुअल टेबल लुकअप किया जाएगा।

Answer 3

स्टेटिक बाध्यकारी: यदि फ़ंक्शन कॉलिंग संकलन समय पर ज्ञात है तो इसे स्थिर बाध्यकारी के रूप में जाना जाता है। स्थिर बाध्यकारी प्रकार के ऑब्जेक्ट मामले में उचित रूप से उपयुक्त फ़ंक्शन कहा जाता है। जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है obj_a.fun() यहां obj_a कक्षा ए का है इसलिए क्लास के मज़ेदार() को बुलाया जाता है।

#include<iostream> 
using namespace std; 
class A{ 
public: 
void fun() 
{cout<<"hello world\n";} 

}; 
class B:public A{ 
public: 
void show() 
{cout<<"how are you ?\n";} 

}; 

int main() 
{ 
A obj_a;   //creating objects 
B obj_b; 
obj_a.fun();  //it is known at compile time that it has to call fun() 
obj_b.show();  //it is known at compile time that it has to call show() 
return 0; 
} 

गतिशील बंधन: अगर समारोह बुला रन टाइम तो यह गतिशील बंधन के रूप में जाना जाता है पर जाना जाता है। हम वर्चुअल कीवर्ड का उपयोग कर देर से बाध्यकारी प्राप्त करते हैं। बेस पॉइंटर भी बाल पॉइंटर्स का पता रख सकता है। इसलिए सूचक की इस सामग्री matter.whether सूचक आधार वर्ग या बच्चे वर्ग

#include<iostream> 
using namespace std; 

class car{ 
public: 
    virtual void speed() 
    { 
     cout<<"ordinary car: Maximum speed limit is 200kmph\n"; 
    } 
}; 
class sports_car:public car{ 
    void speed() 
    { 
     cout<<"Sports car: Maximum speed is 300kmph\n"; 
    } 
}; 

int main() 
{ 
car *ptr , car_obj;  // creating object and pointer to car 
sports_car sport_car_obj; //creating object of sport_car 
ptr = &sport_car_obj;  // assigining address of sport_car to pointer 
          //object of car 
ptr->speed(); // it will call function of sports_car 

return 0; 
} 

का पता कर रहा है अगर हम कार वर्ग से आभासी कीवर्ड निकाल तो यह कार वर्ग के समारोह फोन करेगा में। लेकिन अब यह sport_car वर्ग की गति समारोह बुला रहा है। यह गतिशील बाध्यकारी है क्योंकि फ़ंक्शन के दौरान पॉइंटर के मामले को पॉइंटर का प्रकार नहीं कहा जाता है। क्योंकि पीआरटी टाइप कार की है लेकिन sport_car का पता धारण कर रहा है, यही कारण है कि sport_car speed() को कॉल किया जाता है।