म्यूटेटर विधि

From Vigyanwiki
Revision as of 21:44, 18 February 2023 by alpha>Ashutoshyadav

कंप्यूटर विज्ञान में, एक म्यूटेटर विधि एक वेरिएबल (चर) में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली विधि है। उन्हें व्यापक रूप से सेटर विधियों के रूप में भी जाना जाता है। प्रायः एक सेटर के साथ एक गेटर होता है जिसको एक साथ एक्सेसर के रूप में भी जाना जाता है जो निजी वेरिएबल के मान को वापस करता है।

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

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

प्रोग्रामिंग भाषाओं में जो उनका समर्थन करते हैं और उपयुक्त केप्सूलीकरण प्रोग्रामिंग की उपयोगिता के अतिरिक्त एक सुविधाजनक विकल्प प्रदान करते हैं। नीचे दिए गए उदाहरणों में, किसी घटना को स्थगित करने के लिए पूर्ण रूप से कार्यान्वित म्यूटेटर विधि भी इनपुट डेटा को स्वीकृत कर सकती है।

निहितार्थ

म्यूटेटर और एक्सेसर्स विधियों या ब्लॉकों को परिभाषित करने का विकल्प वेरिएबल को निजी के अतिरिक्त कुछ दृश्यता प्रदान करना होता है और इसे प्रत्यक्ष रूप से ऑब्जेक्ट कोड के अतिरिक्त अन्य सोर्स कोड से नियंत्रित करना होता है। म्यूटेटर और एक्सेसर्स का उपयोग करके एक्सेस अधिकारों के अपेक्षाकृत अधिक नियंत्रण को परिभाषित किया जा सकता है। उदाहरण के लिए, एक पैरामीटर को केवल एक एक्सेसर को परिभाषित करके केवल पढ़ने के लिए बनाया जा सकता है, लेकिन एक म्यूटेटर नहीं। दो विधियों की दृश्यता भिन्न हो सकती है; एक्सेसर के सार्वजनिक होने के लिए यह प्रायः उपयोगी होता है जबकि म्यूटेटर संरक्षित, पैकेज-निजी या आंतरिक रहता है।

वह ब्लॉक (प्रोग्रामिंग) जहां म्यूटेटर परिभाषित किया गया है, आने वाले डेटा के सत्यापन या प्रीप्रोसेसिंग का अवसर प्रदान करता है। यदि सभी बाहरी पहुंच को म्यूटेटर के माध्यम से आने की गारंटी दी जाती है, तो इन वेरिएबलणों को बायपास नहीं किया जा सकता है। उदाहरण के लिए, यदि किसी दिनांक को अलग-अलग निजी year, month और day के वेरिएबल द्वारा दर्शाया जाता है, तो आने वाली तिथियों को setDate म्यूटेटर द्वारा विभाजित किया जा सकता है, जबकि निरंतरता के लिए समान निजी उदाहरण वेरिएबल को setYear और setMonth द्वारा एक्सेस किया जाता है। सभी मामलों में 1 - 12 के बाहर के महीने के मूल्यों को उसी कोड द्वारा अस्वीकार किया जा सकता है।

एक्सेसर्स इसके विपरीत आंतरिक वेरिएबल से उपयोगी डेटा अभ्यावेदन के संश्लेषण की अनुमति देते हैं जबकि उनकी संरचना को बाहरी मॉड्यूल से अलग और छिपा हुआ रखते हैं। एक मौद्रिक getAmount एक्सेसर एक छिपे हुए currency पैरामीटर द्वारा परिभाषित दशमलव स्थानों की संख्या के साथ एक संख्यात्मक वेरिएबल से एक स्ट्रिंग बना सकता है।

आधुनिक प्रोग्रामिंग भाषाएं प्रायः एक ही पंक्ति में म्यूटेटर और एक्सेसर्स के लिए बॉयलरप्लेट कोड उत्पन्न करने की क्षमता प्रदान करती हैं - उदाहरण के लिए C#'spublic string Name { get; set; } और रूबी का attr_accessor :name इन मामलों में, सत्यापन, प्रीप्रोसेसिंग या संश्लेषण के लिए कोई कोड ब्लॉक नहीं बनाया जाता है। ये सरलीकृत एक्सेसर्स अभी भी सरल सार्वजनिक उदाहरण वेरिएबल पर एनकैप्सुलेशन के लाभ को बरकरार रखते हैं, लेकिन यह सामान्य है कि जैसे-जैसे सिस्टम डिजाइन प्रगति करता है, सॉफ्टवेयर बनाए रखा जाता है और आवश्यकताएं बदलती हैं, डेटा की मांग अधिक परिष्कृत हो जाती है। कई स्वचालित म्यूटेटर और एक्सेसर्स अंततः कोड के अलग-अलग ब्लॉकों द्वारा प्रतिस्थापित किए जाते हैं। कार्यान्वयन के शुरुआती दिनों में उन्हें स्वचालित रूप से बनाने का लाभ यह है कि वर्ग का सार्वजनिक इंटरफ़ेस समान रहता है चाहे अधिक परिष्कार जोड़ा जाए या नहीं, यदि कोई व्यापक रिफैक्टरिंग की आवश्यकता नहीं है।[1]

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

इसमें शामिल अतिरिक्त वेरिएबलणों के कारण डेटा फ़ील्ड को सीधे लाने या संग्रहीत करने की तुलना में एक्सेसर फ़ंक्शन कम कुशल हो सकते हैं,[2] हालाँकि ऐसे कार्य प्रायः इनलाइन फ़ंक्शन होते हैं जो फ़ंक्शन कॉल के ओवरहेड को समाप्त कर देते हैं।

उदाहरण

सभा

student                   struct
    age         dd        ?
student                   end   .code
student_get_age       proc      object:DWORD
                      mov       ebx, object
                      mov       eax, student.age[ebx]
                      ret
student_get_age       endp

student_set_age       proc      object:DWORD, age:DWORD
                      mov       ebx, object
                      mov       eax, age
                      mov       student.age[ebx], eax
                      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>
#include "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);
}

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;
}
 #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);
  int new_age = student_get_age(s);
  printf("%s's new age = %i\n", name, new_age);
  student_delete(s);
  return 0;
}

all: out.txt; cat $<
out.txt: main; ./$< > $@
main: main.o student.o
main.o student.o: student.h
clean: ;$(RM) *.o out.txt main

सी ++

#ifndef STUDENT_H
#define 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;
}

सी#

यह उदाहरण गुणों के सी # विचार को दिखाता है, जो एक विशेष प्रकार के वर्ग सदस्य हैं। जावा के विपरीत, कोई स्पष्ट तरीके परिभाषित नहीं हैं; एक सार्वजनिक 'संपत्ति' में क्रियाओं को संभालने के लिए तर्क होता है। बिल्ट-इन (अघोषित) वेरिएबल value के उपयोग पर ध्यान दें। 

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 और ऊपर) में, निजी वेरिएबल घोषित किए बिना, इस उदाहरण को संक्षिप्त रूप में निम्नानुसार किया जा सकता है name.

बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी वेरिएबल name घोषित किए बिना, इस उदाहरण को निम्नानुसार संक्षिप्त किया जा सकता है। 

public class Student
{
    public string Name { get; set; }
}

संक्षिप्त सिंटैक्स का उपयोग करने का अर्थ है कि अंतर्निहित वेरिएबल अब कक्षा के अंदर से उपलब्ध नहीं है। नतीजतन, संपत्ति का set हिस्सा असाइनमेंट के लिए मौजूद होना चाहिए। एक्सेस को set-विशिष्ट एक्सेस संशोधक के साथ प्रतिबंधित किया जा सकता है। 

public class Student
{
    public string Name { get; private set; }
}

सामान्य लिस्प

कॉमन लिस्प ऑब्जेक्ट सिस्टम में, क्लास परिभाषाओं के भीतर स्लॉट स्पेसिफिकेशंस इनमें से किसी को भी निर्दिष्ट कर सकते हैं :reader, :writer और :accessor पाठक विधियों, सेटर विधियों और एक्सेसर विधियों (एक पाठक विधि और संबंधित setf तरीका)।[3] के उपयोग के साथ स्लॉट हमेशा उनके नाम के माध्यम से सीधे पहुंच योग्य होते हैं with-slots और slot-value, और स्लॉट एक्सेसर विकल्प उपयोग करने वाली विशेष विधियों को परिभाषित करते हैं slot-value.[4]

सीएलओएस के पास गुणों की कोई धारणा नहीं है, हालांकि कॉमन लिस्प ऑब्जेक्ट सिस्टम#मेटाओब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के रीडर और लेखक फ़ंक्शन नामों तक पहुंचने के लिए, जिसमें से उत्पन्न होते हैं :accessor विकल्प।[5] निम्न उदाहरण इन स्लॉट विकल्पों और डायरेक्ट स्लॉट एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा दिखाता है: 

(defclass student ()
  ((name      :initarg :name      :initform "" :accessor student-name) ; student-name is setf'able
   (birthdate :initarg :birthdate :initform 0  :reader student-birthdate)
   (number    :initarg :number    :initform 0  :reader student-number :writer set-student-number)))

;; Example of a calculated property getter (this is simply a method)
(defmethod student-age ((self student))
  (- (get-universal-time) (student-birthdate self)))

;; Example of direct slot access within a calculated property setter
(defmethod (setf student-age) (new-age (self student))
  (with-slots (birthdate) self
    (setf birthdate (- (get-universal-time) new-age))
    new-age))

;; The slot accessing options generate methods, thus allowing further method definitions
(defmethod set-student-number :before (new-number (self student))
  ;; You could also check if a student with the new-number already exists.
  (check-type new-number (integer 1 *)))

डी

डी (प्रोग्रामिंग भाषा) और सेटर फ़ंक्शन सिंटैक्स का समर्थन करता है। भाषा गेट्टर और सेटर वर्ग/संरचना विधियों के संस्करण 2 में @property विशेषता होनी चाहिए।[6][7] 

   class Student {
    private char[] name_;
    // Getter
    @property char[] name() {
        return this.name_;
    }
    // Setter
    @property char[] name(char[] name_in) {
        return this.name_ = name_in;
    }
}

एक Student उदाहरण इस तरह इस्तेमाल किया जा सकता है: 

auto student = new Student;
student.name = "David";           // same effect as student.name("David")
auto student_name = student.name; // same effect as student.name()

डेल्फी

यह डेल्फी भाषा में एक साधारण वर्ग है जो एक निजी क्षेत्र तक पहुँचने के लिए सार्वजनिक संपत्ति की अवधारणा को दर्शाता है। 

interface
type
  TStudent = class
  strict private
    FName: string;
    procedure SetName(const Value: string);
  public
    /// <summary>
    /// Get or set the name of the student.
    /// </summary>
    property Name: string read FName write SetName;
  end;

// ...

implementation

procedure TStudent.SetName(const Value: string);
begin
  FName := Value;
end;

end.

जावा

एक छात्र का प्रतिनिधित्व करने वाले एक साधारण वर्ग के इस उदाहरण में केवल संग्रहीत नाम के साथ, कोई देख सकता है कि वेरिएबल नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है, और "सेटर" और "गेटर" सार्वजनिक हैं, अर्थात् getName()" और "setName(name)" विधियां। 

public class Student {
    private String name;

    public String getName() {
        return name;
    }
    
    public void setName(String newName) {
        name = newName;
    }
}

जावास्क्रिप्ट

इस उदाहरण में कंस्ट्रक्टर-फंक्शन स्टूडेंट का उपयोग केवल संग्रहीत नाम वाले छात्र का प्रतिनिधित्व करने वाली वस्तुओं को बनाने के लिए किया जाता है। 

function Student(name) {
  var _name = name;

  this.getName = function() {
    return _name;
  };

  this.setName = function(value) {
    _name = value;
  };
}

या (वेब ​​ब्राउज़रों में एक्सेसर्स को परिभाषित करने के लिए बहिष्कृत तरीके का उपयोग करते हुए 

  function Student(name)
{    var _name = name;
   
    this.__defineGetter__('name', function() {
        return _name;
    });
   
    this.__defineSetter__('name', function(value) {
        _name = value;
    });
}

या (वंशानुक्रम और ES6 एक्सेसर सिंटैक्स के लिए प्रोटोटाइप का उपयोग करके 

function Student(name){
    this._name = name;
}

Student.prototype = {
    get name() {
        return this._name;
    },
    set name(value) {
        this._name = value;
    } 

या (प्रोटोटाइप का उपयोग किए बिना): 

  var Student = {
    get name() {
        return this._name;
    },
    set name(value) {
        this._name = value;
    }
};

या (डिफाइनप्रॉपर्टी का उपयोग करके): 

function Student(name){
   this._name = name;
}
Object.defineProperty(Student.prototype, 'name', {
    get: function() {
        return this._name;
    },
    set: function(value) {
        this._name = value;
    }
});

एक्शनस्क्रिप्ट 3.0

package
{
    public class Student
    {
        private var _name : String;
		
        public function get name() : String
        { 
            return _name;
        }

        public function set name(value : String) : void
        {
            _name = value;
        }
    }
}

उद्देश्य-सी

Ubuntu 12.04 पर GNUstep पर काम करने वाले के रूप में मैनुअल रेफरेंस काउंटिंग के साथ पारंपरिक ऑब्जेक्टिव-सी 1.0 सिंटैक्स का उपयोग करना: 

   @interface Student : NSObject
{
    NSString *_name;
}

- (NSString *)name;
- (void)setName:(NSString *)name;

@end

@implementation Student

- (NSString *)name
{
    return _name;
}

- (void)setName:(NSString *)name
{
    [_name release];
    _name = [name retain];
}

@end

Mac OS X 10.6, iOS 4 और Xcode 3.2 में उपयोग किए गए नए Objective-C 2.0 सिंटैक्स का उपयोग करते हुए, ऊपर बताए अनुसार समान कोड जनरेट करना: 

@interface Student : NSObject

@property (nonatomic, retain) NSString *name;

@end

@implementation Student

@synthesize name = _name;

@end

और OS X 10.8 और iOS 6 से शुरू करते हुए, Xcode 4.4 और ऊपर का उपयोग करते हुए, सिंटैक्स को और भी सरल बनाया जा सकता है: 

@interface Student : NSObject

@property (nonatomic, strong) NSString *name;

@end

@implementation Student

//Nothing goes here and it's OK.

@end

पर्ल

package Student;

sub new {
    bless {}, shift;
}

sub set_name {
    my $self = shift;
    $self->{name} = $_[0];
}

sub get_name {
    my $self = shift;
    return $self->{name};
}

1;

या, कक्षा :: एक्सेसर का उपयोग करना 

package Student;
use base qw(Class::Accessor);
__PACKAGE__->follow_best_practice;

Student->mk_accessors(qw(name));

1;

या, मूस (पर्ल) ऑब्जेक्ट सिस्टम का उपयोग करना: 

package Student;
use Moose;

# Moose uses the attribute name as the setter and getter, the reader and writer properties
# allow us to override that and provide our own names, in this case get_name and set_name
has 'name' => (is => 'rw', isa => 'Str', reader => 'get_name', writer => 'set_name');

1;

पीएचपी

PHP जादू के तरीकों को परिभाषित करती है __getऔर__set वस्तुओं के गुणों के लिए।[8] एक सरल वर्ग (कंप्यूटर विज्ञान) के इस उदाहरण में एक छात्र का प्रतिनिधित्व करने वाला केवल नाम संग्रहीत है, कोई देख सकता है कि वेरिएबल (प्रोग्रामिंग) नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है, और सेटर और गेट्टर सार्वजनिक है, अर्थात् getName() और setName('name') तरीके। 

class Student
{
    private string $name;

    /**
     * @return string The name.
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * @param string $newName The name to set.
     */
    public function setName(string $newName): void
    {
        $this->name = $newName;
    }
}

पायथन

यह उदाहरण एक वेरिएबल, एक गेट्टर और एक सेटर के साथ एक पायथन वर्ग का उपयोग करता है। 

class Student:
    # Initializer
    def __init__(self, name: str) -> None:
        # An instance variable to hold the student's name
        self._name = name

    # Getter method
    @property
    def name(self):
        return self._name

    # Setter method
    @name.setter
    def name(self, new_name):
        self._name = new_name

>>> bob = Student("Bob")
>>> bob.name 
Bob
>>> bob.name = "Alice"
>>> bob.name 
Alice
>>> bob._name = "Charlie" # bypass the setter
>>> bob._name # bypass the getter
Charlie

रैकेट

रैकेट (प्रोग्रामिंग भाषा) में, ऑब्जेक्ट सिस्टम कोड को व्यवस्थित करने का एक तरीका है जो मॉड्यूल और यूनिट के अतिरिक्त आता है। बाकी भाषा की तरह, ऑब्जेक्ट सिस्टम में प्रथम श्रेणी के मान हैं और वस्तुओं और विधियों तक पहुंच को नियंत्रित करने के लिए लेक्सिकल स्कोप का उपयोग किया जाता है। 

#lang racket
(define student%
  (class object%
    (init-field name)
    (define/public (get-name) name)
    (define/public (set-name! new-name) (set! name new-name))
    (super-new)))

(define s (new student% [name "Alice"]))
(send s get-name)                       ; => "Alice"
(send s set-name! "Bob")
(send s get-name)                       ; => "Bob"

संरचनात्मक परिभाषाएँ नए प्रकार के मूल्यों को परिभाषित करने का एक वैकल्पिक तरीका है, जब स्पष्ट रूप से आवश्यक होने पर म्यूटेटर मौजूद होते हैं: 

#lang racket
(struct student (name) #:mutable)
(define s (student "Alice"))
(set-student-name! s "Bob")
(student-name s)                        ; => "Bob"

रुबी

रुबी में, अलग-अलग एक्सेसर और म्यूटेटर विधियों को परिभाषित किया जा सकता है, या मेटाप्रोग्रामिंग attr_reader या attr_accessorदोनों का उपयोग कक्षा में एक निजी वेरिएबल घोषित करने के लिए किया जा सकता है और क्रमशः पढ़ने-योग्य या पढ़ने-लिखने के लिए सार्वजनिक पहुंच प्रदान करने के लिए किया जा सकता है। 

class Student
  def name
    @name
  end

  def name=(value)
    @name=value
  end
end

निहित @name वेरिएबल के लिए केवल-पढ़ने के लिए सरल सार्वजनिक पहुंच 

class Student
  attr_reader :name
end

निहित @nameवेरिएबल के लिए सरल सार्वजनिक पहुंच पढ़ें-लिखें 

class Student
  attr_accessor :name
end

रस्ट

struct Student {
    name: String,
}

impl Student {
    fn name(&self) -> &String {
        &self.name
    }

    fn set_name(&mut self, name: String) {
        self.name = name
    }
}

स्मालटॉक

 age: aNumber
     " Set the receiver age to be aNumber if is greater than 0 and less than 150 "
    (aNumber between: 0 and: 150)
       ifTrue: [ age := aNumber ]

तेज

class Student {
    private var _name: String = ""

    var name: String {
        get {
            return self._name
        }
        set {
            self._name = newValue
        }
    }
}

विजुअल बेसिक .NET

यह उदाहरण कक्षाओं में उपयोग किए जाने वाले गुणों के VB.NET विचार को दिखाता है। सी # के समान, Get और Set विधियों का स्पष्ट उपयोग होता है। 

Public Class Student

    Private _name As String

    Public Property Name()
        Get
            Return _name
        End Get
        Set(ByVal value)
            _name = value
        End Set
    End Property

End Class

VB.NET 2010 में, Get और Set Get सिंटैक्स का उपयोग किए बिना एक संपत्ति बनाने के लिए ऑटो इम्प्लीमेंटेड गुणों का उपयोग किया जा सकता है। ध्यान दें कि एक छुपा वेरिएबल संकलक द्वारा बनाया गया है, जिसे कहा जाता है _name के साथ मेल खाने के लिए name. नामित वर्ग के भीतर एक अन्य वेरिएबल का उपयोग करना _name एक त्रुटि में परिणाम होगा। अंतर्निहित वेरिएबल के लिए विशेषाधिकार प्राप्त पहुँच कक्षा के भीतर से उपलब्ध है। 

Public Class Student
    Public Property name As String
End Class

यह भी देखें

संदर्भ

  1. ↑ Stephen Fuqua (2009). "Automatic Properties in C# 3.0". Archived from the original on 2011-05-13. Retrieved 2009-10-19.
  2. ↑ Tim Lee (1998-07-13). "Run Time Efficiency of Accessor Functions".
  3. ↑ "CLHS: Macro DEFCLASS". Retrieved 2011-03-29.
  4. ↑ "CLHS: 7.5.2 Accessing Slots". Retrieved 2011-03-29.
  5. ↑ "MOP: Slot Definitions". Retrieved 2011-03-29.
  6. ↑ "Functions - D Programming Language". Retrieved 2013-01-13.{{cite web}}: CS1 maint: url-status (link)
  7. ↑ "The D Style". Retrieved 2013-02-01.
  8. ↑ "PHP: Overloading - Manual". www.php.net. Retrieved 2021-07-06.
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=म्यूटेटर_विधि&oldid=92451’