म्यूटेटर विधि: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 1: Line 1:
[[कंप्यूटर विज्ञान]] में, एक म्यूटेटर विधि एक चर में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली [[विधि (कंप्यूटर विज्ञान)|विधि]] है। उन्हें व्यापक रूप से सेटर विधियों के रूप में भी जाना जाता है। अक्सर एक सेटर के साथ एक गेट्टर (एक साथ एक्सेसर्स के रूप में भी जाना जाता है) होता है, जो निजी [[सदस्य चर]] का मान लौटाता है।
[[कंप्यूटर विज्ञान]] में, एक '''म्यूटेटर विधि''' एक चर में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली [[विधि (कंप्यूटर विज्ञान)|विधि]] है। उन्हें व्यापक रूप से सेटर विधियों के रूप में भी जाना जाता है। अक्सर एक सेटर के साथ एक गेट्टर (एक साथ एक्सेसर्स के रूप में भी जाना जाता है) होता है, जो निजी [[सदस्य चर]] का मान लौटाता है।


एनकैप्सुलेशन के सिद्धांत को ध्यान में रखते हुए, म्यूटेटर विधि का उपयोग अक्सर [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] में किया जाता है। इस सिद्धांत के अनुसार, एक वर्ग के सदस्य [[चर (प्रोग्रामिंग)]] को छिपाने और उन्हें अन्य कोड से बचाने के लिए निजी बनाया जाता है, और इसे केवल एक सार्वजनिक सदस्य फ़ंक्शन (म्यूटेटर विधि) द्वारा संशोधित किया जा सकता है, जो पैरामीटर के रूप में वांछित नया मान लेता है, वैकल्पिक रूप से मान्य करता है यह, और निजी सदस्य चर को संशोधित करता है। म्यूटेटर विधियों की तुलना असाइनमेंट [[ऑपरेटर ओवरलोडिंग]] से की जा सकती है लेकिन वे आम तौर पर ऑब्जेक्ट पदानुक्रम के विभिन्न स्तरों पर दिखाई देते हैं।
एनकैप्सुलेशन के सिद्धांत को ध्यान में रखते हुए, म्यूटेटर विधि का उपयोग अक्सर [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] में किया जाता है। इस सिद्धांत के अनुसार, एक वर्ग के सदस्य [[चर (प्रोग्रामिंग)]] को छिपाने और उन्हें अन्य कोड से बचाने के लिए निजी बनाया जाता है, और इसे केवल एक सार्वजनिक सदस्य फ़ंक्शन (म्यूटेटर विधि) द्वारा संशोधित किया जा सकता है, जो पैरामीटर के रूप में वांछित नया मान लेता है, वैकल्पिक रूप से मान्य करता है यह, और निजी सदस्य चर को संशोधित करता है। म्यूटेटर विधियों की तुलना असाइनमेंट [[ऑपरेटर ओवरलोडिंग]] से की जा सकती है लेकिन वे आम तौर पर ऑब्जेक्ट पदानुक्रम के विभिन्न स्तरों पर दिखाई देते हैं।
Line 25: Line 25:
}}</ref>
}}</ref>


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


इसमें शामिल अतिरिक्त चरणों के कारण डेटा फ़ील्ड को सीधे लाने या संग्रहीत करने की तुलना में एक्सेसर फ़ंक्शन कम कुशल हो सकते हैं,<ref>{{cite web
इसमें शामिल अतिरिक्त चरणों के कारण डेटा फ़ील्ड को सीधे लाने या संग्रहीत करने की तुलना में एक्सेसर फ़ंक्शन कम कुशल हो सकते हैं,<ref>{{cite web
Line 37: Line 37:


=== सभा ===
=== सभा ===
<वाक्यविन्यास प्रकाश लैंग = nasm>
student                  struct
छात्र संरचना
    age        dd        ?
    उम्र डीडी?
student                  end  .code
छात्र समाप्त
student_get_age      proc      object:DWORD
</वाक्यविन्यास हाइलाइट>
                      mov      ebx, object
<वाक्यविन्यास प्रकाश लैंग = nasm>
                      mov      eax, student.age[ebx]
                    कोड
                      ret
स्टूडेंट_गेट_एज प्रो ऑब्जेक्ट:DWORD
student_get_age      endp
                      मूव ईबीएक्स, ऑब्जेक्ट
                      मूव ईएक्स, स्टूडेंट.एज[ईबीएक्स]
student_set_age      proc      object:DWORD, age:DWORD
                      गीला करना
                      mov      ebx, object
स्टूडेंट_गेट_एज एंडप
                      mov      eax, age
 
                      mov      student.age[ebx], eax
स्टूडेंट_सेट_एज प्रो ऑब्जेक्ट: DWORD, आयु: DWORD
                      ret
                      मूव ईबीएक्स, ऑब्जेक्ट
student_set_age      endp
                      मूव ईएक्स, उम्र
                      मूव स्टूडेंट.एज [ईबीएक्स], ईएक्स
                      गीला करना
छात्र_सेट_आयु अंत
</वाक्यविन्यास हाइलाइट>


=== सी ===
=== सी ===
#ifndef _STUDENT_H
#define _STUDENT_H
struct student; /* opaque structure */
typedef struct student student;
student *student_new(int age, char *name);
void student_delete(student *s);
void student_set_age(student *s, int age);
int student_get_age(student *s);
char *student_get_name(student *s);
#endif


फ़ाइल छात्र में। एच:
#include <stdlib.h>
<वाक्यविन्यास लैंग = सी>
#include <string.h>
#ifndef _STUDENT_H
#include "student.h"
#STUDENT_H को परिभाषित करें
 
struct student {
संरचना छात्र; / * अपारदर्शी संरचना * /
  int age;
टाइपपीफ संरचना छात्र छात्र;
  char *name;
 
};
छात्र * छात्र_ नया (अंतर आयु, चार * नाम);
शून्य छात्र_डिलीट (छात्र * एस);
student *student_new(int age, char *name) {
 
  student *s = malloc(sizeof(student));
शून्य छात्र_सेट_एज (छात्र * एस, इंट आयु);
  s->name = strdup(name);
इंट स्टूडेंट_गेट_एज (स्टूडेंट * एस);
  s->age = age;
चार * छात्र_गेट_नाम (छात्र * एस);
  return s;
 
}
#अगर अंत
</वाक्यविन्यास हाइलाइट>
void student_delete(student *s) {
 
  free(s->name);
फ़ाइल छात्र.सी में:
  free(s);
<वाक्यविन्यास लैंग = सी>
}
#शामिल <stdlib.h>
#शामिल <string.h>
void student_set_age(student *s, int age) {
#छात्र शामिल करें
  s->age = age;
 
}
संरचना छात्र {
  अंतर आयु;
int student_get_age(student *s) {
  नौकरानी का नाम;
  return s->age;
};
}
 
छात्र * छात्र_ नया (पूर्णांक आयु, चार * नाम) {
char *student_get_name(student *s) {
  छात्र * एस = मॉलोक (आकार (छात्र));
  return s->name;
  एस-> नाम = strdup (नाम);
}
  s->उम्र = आयु;
  #include <stdio.h>
  वापसी एस;
#include "student.h"
}
 
int main(void) {
शून्य छात्र_हटाएं (छात्र *) {
  student *s = student_new(19, "Maurice");
  मुक्त (एस-> नाम);
  char *name = student_get_name(s);
  मुफ़्त (ओं);
  int old_age = student_get_age(s);
}
  printf("%s's old age = %i\n", name, old_age);
 
  student_set_age(s, 21);
शून्य छात्र_सेट_उम्र (छात्र *s, अंतर उम्र) {
  int new_age = student_get_age(s);
  s->उम्र = आयु;
  printf("%s's new age = %i\n", name, new_age);
}
  student_delete(s);
 
  return 0;
इंट स्टूडेंट_गेट_एज (स्टूडेंट * एस) {
}
  वापसी एस-> उम्र;
}
 
चार * छात्र_गेट_नाम (छात्र * एस) {
  वापसी एस-> नाम;
}
</वाक्यविन्यास हाइलाइट>
 
फ़ाइल main.c में:
<वाक्यविन्यास लैंग = सी>
#शामिल <stdio.h>
#छात्र शामिल करें


पूर्णांक मुख्य (शून्य) {
all: out.txt; cat $<
  छात्र *s = छात्र_नया (19, मौरिस);
out.txt: main; ./$< > $@
  चार * नाम = छात्र_नाम_नाम;
main: main.o student.o
  int old_age = छात्र_get_age(s);
main.o student.o: student.h
  प्रिंटफ (% s की वृद्धावस्था =% i \ n, नाम, Old_age);
clean: ;$(RM) *.o out.txt main
  छात्र_सेट_उम्र (एस, 21);
  int new_age = छात्र_प्राप्त_उम्र;
  प्रिंटफ (% s की नई आयु =% i \ n, नाम, new_age);
  छात्र_हटाएं;
  वापसी 0;
}
</वाक्यविन्यास हाइलाइट>
 
फ़ाइल मेकफ़ाइल में:
<वाक्यविन्यास लैंग = मेकफाइल>
सब: out.txt; बिल्ली $<
out.txt: मुख्य; ./$< > $@
मुख्य: main.o छात्र.o
main.o छात्र.o: छात्र.एच
साफ: ;$(RM) *.o out.txt main
</वाक्यविन्यास हाइलाइट>


=== सी ++ ===
=== सी ++ ===
फ़ाइल छात्र में। एच:
#ifndef STUDENT_H
<वाक्यविन्यास लैंग = सीपीपी>
#define STUDENT_H
#ifndef STUDENT_H
#छात्र_एच को परिभाषित करें
#include <string>
 
#शामिल <स्ट्रिंग>
class Student {
 
public:
कक्षा छात्र {
    Student(const std::string& name);
जनता:
    छात्र (स्थिरांक एसटीडी :: स्ट्रिंग और नाम);
    const std::string& name() const;
 
    void name(const std::string& name);
    स्थिरांक एसटीडी :: स्ट्रिंग और नाम () स्थिरांक;
    शून्य नाम (स्थिरांक एसटीडी :: स्ट्रिंग और नाम);
private:
 
    std::string name_;
निजी:
};
    एसटीडी :: स्ट्रिंग नाम_;
};
#endif
 
In file Student.cpp:
#अगर अंत
#include "Student.h"
</वाक्यविन्यास हाइलाइट>
फ़ाइल में छात्र.सीपीपी:
Student::Student(const std::string& name) : name_(name) {
<वाक्यविन्यास लैंग = सीपीपी>
}
# शामिल छात्र। एच
 
const std::string& Student::name() const {
छात्र :: छात्र (स्थिरांक एसटीडी :: स्ट्रिंग और नाम): नाम_ (नाम) {
    return name_;
}
}
 
स्थिरांक एसटीडी :: स्ट्रिंग और छात्र :: नाम () स्थिरांक {
void Student::name(const std::string& name) {
    वापसी का नाम_;
    name_ = name;
}
}
 
शून्य छात्र :: नाम (स्थिरांक एसटीडी :: स्ट्रिंग और नाम) {
    नाम_ = नाम;
}
</वाक्यविन्यास हाइलाइट>


===सी#===
===सी#===
यह उदाहरण C Sharp (प्रोग्रामिंग लैंग्वेज)|C# प्रॉपर्टी के विचार (प्रोग्रामिंग)#C# को दिखाता है, जो एक विशेष प्रकार के क्लास (कंप्यूटर साइंस) सदस्य हैं। जावा के विपरीत, कोई स्पष्ट तरीके परिभाषित नहीं हैं; एक सार्वजनिक 'संपत्ति' में क्रियाओं को संभालने के लिए तर्क होता है। बिल्ट-इन (अघोषित) वेरिएबल के उपयोग पर ध्यान दें <code>value</code>.
यह उदाहरण गुणों के सी # विचार को दिखाता है, जो एक विशेष प्रकार के वर्ग सदस्य हैं। जावा के विपरीत, कोई स्पष्ट तरीके परिभाषित नहीं हैं; एक सार्वजनिक 'संपत्ति' में क्रियाओं को संभालने के लिए तर्क होता है। बिल्ट-इन (अघोषित) वेरिएबल <code>value</code> के उपयोग पर ध्यान दें।
public class Student
{
    private string name;
    /// <summary>
    /// Gets or sets student's name
    /// </summary>
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}
बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर घोषित किए बिना, इस उदाहरण को संक्षिप्त रूप में निम्नानुसार किया जा सकता है <code>name</code>.


<वाक्यविन्यास प्रकाश लैंग = csharp>
बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर <code>name</code> घोषित किए बिना, इस उदाहरण को निम्नानुसार संक्षिप्त किया जा सकता है।
सार्वजनिक वर्ग छात्र
{
    निजी स्ट्रिंग नाम;


    /// <सारांश>
public class Student
    /// छात्र का नाम प्राप्त या सेट करता है
{
    /// </ सारांश>
    public string Name { get; set; }
    सार्वजनिक स्ट्रिंग नाम
}
    {
संक्षिप्त सिंटैक्स का उपयोग करने का अर्थ है कि अंतर्निहित चर अब कक्षा के अंदर से उपलब्ध नहीं है। नतीजतन, संपत्ति का <code>set</code> हिस्सा असाइनमेंट के लिए मौजूद होना चाहिए। एक्सेस को <code>set</code>-विशिष्ट एक्सेस संशोधक के साथ प्रतिबंधित किया जा सकता है।
        प्राप्त करें {वापसी का नाम; }
        सेट {नाम = मान; }
    }
}
</वाक्यविन्यास हाइलाइट>


बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर घोषित किए बिना, इस उदाहरण को संक्षिप्त रूप में निम्नानुसार किया जा सकता है <code>name</code>.
public class Student
 
{
<वाक्यविन्यास प्रकाश लैंग = csharp>
    public string Name { get; private set; }
सार्वजनिक वर्ग छात्र
}
{
    सार्वजनिक स्ट्रिंग नाम {प्राप्त करें; तय करना; }
}
</वाक्यविन्यास हाइलाइट>
 
संक्षिप्त सिंटैक्स का उपयोग करने का अर्थ है कि अंतर्निहित चर अब कक्षा के अंदर से उपलब्ध नहीं है। परिणामस्वरूप, द <code>set</code> संपत्ति का हिस्सा असाइनमेंट के लिए मौजूद होना चाहिए। एक्सेस को a से प्रतिबंधित किया जा सकता है <code>set</code>विशिष्ट पहुँच संशोधक।
<वाक्यविन्यास प्रकाश लैंग = csharp>
सार्वजनिक वर्ग छात्र
{
    सार्वजनिक स्ट्रिंग नाम {प्राप्त करें; निजी सेट; }
}
</वाक्यविन्यास हाइलाइट>


=== सामान्य लिस्प ===
=== सामान्य लिस्प ===
Line 218: Line 188:
सीएलओएस के पास गुणों की कोई धारणा नहीं है, हालांकि कॉमन लिस्प ऑब्जेक्ट सिस्टम#मेटाओब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के रीडर और लेखक फ़ंक्शन नामों तक पहुंचने के लिए, जिसमें से उत्पन्न होते हैं <code>:accessor</code> विकल्प।<ref name="mop-slot-definitions">{{cite web |url=http://www.lisp.org/mop/concepts.html#slot-definitions |title=MOP: Slot Definitions |accessdate=2011-03-29}}</ref>
सीएलओएस के पास गुणों की कोई धारणा नहीं है, हालांकि कॉमन लिस्प ऑब्जेक्ट सिस्टम#मेटाओब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के रीडर और लेखक फ़ंक्शन नामों तक पहुंचने के लिए, जिसमें से उत्पन्न होते हैं <code>:accessor</code> विकल्प।<ref name="mop-slot-definitions">{{cite web |url=http://www.lisp.org/mop/concepts.html#slot-definitions |title=MOP: Slot Definitions |accessdate=2011-03-29}}</ref>
निम्न उदाहरण इन स्लॉट विकल्पों और डायरेक्ट स्लॉट एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा दिखाता है:
निम्न उदाहरण इन स्लॉट विकल्पों और डायरेक्ट स्लॉट एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा दिखाता है:
<वाक्यविन्यास प्रकाश लैंग = लिस्प>
(defclass student ()
(डिफक्लास छात्र ()
  ((name      :initarg :name      :initform "" :accessor student-name) ; student-name is setf'able
  ((नाम: initarg: नाम: initform: एक्सेसर छात्र-नाम); छात्र-नाम सेट करने योग्य है
    (birthdate :initarg :birthdate :initform 0 :reader student-birthdate)
  (जन्मतिथि :initarg :जन्मतिथि :initform 0 :पाठक छात्र-जन्मतिथि)
    (number   :initarg :number    :initform 0 :reader student-number :writer set-student-number)))
   (संख्या:initarg:संख्या:initform 0:पाठक छात्र-संख्या:लेखक सेट-छात्र-संख्या))
 
;; Example of a calculated property getter (this is simply a method)
;; एक परिकलित संपत्ति प्राप्तकर्ता का उदाहरण (यह केवल एक विधि है)
(defmethod student-age ((self student))
(defmethod छात्र-आयु ((स्वयं छात्र))
  (- (get-universal-time) (student-birthdate self)))
  (- (प्राप्त-सार्वभौमिक-समय) (