Método mutador

En el archivo Student.h :

#pragma una vezstruct Student ; /* estructura opaca */ typedef struct Student Student ;Estudiante * crearEstudiante ( int edad , const char * nombre ); void destruirEstudiante ( const Estudiante * s );void setStudentAge ( Student * s , int age ); int getStudentAge ( const Student * s ); char * getStudentName ( const Student * s );

En el archivo Student.c :

#include <stdlib.h> #include <string.h>#incluir "Student.h"struct Estudiante { int edad ; char * nombre ; };Estudiante * createStudent ( int edad , const char * nombre ) { Estudiante * s = ( Estudiante * ) malloc ( sizeof ( Estudiante )); s -> nombre = strdup ( nombre ); s -> edad = edad ; return s ; }void destroyStudent ( const Student * s ) { free ( s -> name ); free ( s ); }void setStudentAge ( Student * s , int age ) { s -> age = age ; }int getStudentAge ( const Student * s ) { return s -> age ; }char * getStudentName ( const Student * s ) { return s -> name ; }

En el archivo Main.c :

#include <stdio.h>#incluir "Student.h"int main ( void ) { Student * s = createStudent ( 19 , "Maurice" ); char * name = getStudentName ( s ); int old_age = getStudentAge ( s ); printf ( "%s's old age = %i \n " , name , old_age ); setStudentAge ( s , 21 ); int new_age = getStudentAge ( s ); printf ( "%s's new age = %i\ n " , name , new_age ); destroyStudent ( s ); return 0 ; }

En el archivo Makefile:

todo : out.txt ; cat $ < out.txt : main ; ./$ < > $ @ main : Main.o Student.o Main.o Student.o : Student.h clean :; $ ( RM ) * .o out.txt main​​​

En el archivo Student.cppm :

importar std ;usando std :: string ;clase Estudiante { privado : string nombre ; público : Estudiante ( const string & nombre ) : nombre { nombre } {}[[ nodiscard ]] const string & getName () const noexcept { return name ; }void setName ( const string & name ) noexcept { this -> name = name ; } };

Este ejemplo ilustra el concepto de propiedades en C# , que son un tipo especial de miembro de clase . A diferencia de Java, no se definen métodos explícitos; una 'propiedad' pública contiene la lógica para gestionar las acciones. Nótese el uso de la variable integrada (no declarada) .value

clase pública Estudiante { cadena privada nombre ;/// <summary> /// Obtiene o establece el nombre del estudiante /// </summary> public string Name { get { return name ; } set { name = value ; } } }

En versiones posteriores de C# (.NET Framework 3.5 y superiores), este ejemplo puede abreviarse de la siguiente manera, sin declarar la variable privada name.

clase pública Estudiante { cadena pública Nombre { obtener ; establecer ; } }

El uso de la sintaxis abreviada implica que la variable subyacente ya no está disponible desde dentro de la clase. Por lo tanto, la setparte de la propiedad debe estar presente para su asignación. El acceso puede restringirse con un setmodificador de acceso específico.

clase pública Estudiante { cadena pública Nombre { obtener ; establecer ; } }​

En Common Lisp Object System , las especificaciones de ranuras dentro de las definiciones de clase pueden especificar cualquiera de las opciones :reader, :writery (incluso varias veces) para definir métodos de lectura, métodos de asignación y métodos de acceso (un método de lectura y el método respectivo). ^{[ 3 ]} Las ranuras siempre son directamente accesibles a través de sus nombres con el uso de y , y las opciones de acceso de ranura definen métodos especializados que usan . ^{[ 4 ]}:accessorsetfwith-slotsslot-valueslot-value

CLOS en sí mismo no tiene noción de propiedades, aunque la extensión MetaObject Protocol especifica medios para acceder a los nombres de las funciones de lectura y escritura de una ranura, incluidas las generadas con la :accessoropción. ^{[ 5 ]}

El siguiente ejemplo muestra la definición de una clase de estudiante utilizando estas opciones de ranura y acceso directo a la ranura:

( defclass student () (( name :initarg :name :initform "" :accessor student-name ) ; student-name es configurable ( birthdate :initarg :birthdate :initform 0 :reader student-birthdate ) ( number :initarg :number :initform 0 :reader student-number :writer set-student-number )));; Ejemplo de un método para obtener una propiedad calculada (esto es simplemente un método) ( defmethod student-age (( self student )) ( - ( get-universal-time ) ( student-birthdate self )));; Ejemplo de acceso directo a ranuras dentro de un setter de propiedad calculado ( defmethod ( setf student-age ) ( new-age ( self student )) ( with-slots ( birthdate ) self ( setf birthdate ( - ( get-universal-time ) new-age )) new-age ));; Las opciones de acceso a la ranura generan métodos, lo que permite definiciones de métodos adicionales ( defmethod set-student-number :before ( new-number ( self student )) ;; También podrías comprobar si ya existe un estudiante con el nuevo número. ( check-type new-number ( integer 1 * )))

D admite una sintaxis de funciones getter y setter. En la versión 2 del lenguaje, los métodos getter y setter de clase/estructura deben tener el @propertyatributo. ^{[ 6 ] [ 7 ]}

clase Estudiante { cadena privada nombre_ ;// Getter @property string name () { return this . name_ ; }// Setter @property string name ( string name_in ) { return this . name_ = name_in ; } }

Una Studentinstancia se puede utilizar de esta manera:

Estudiante s = nuevo Estudiante ; s.nombre = " David" ; // mismo efecto que estudiante.nombre("David") cadena nombre_estudiante = s.nombre ; // mismo efecto que estudiante.nombre( )

Esta es una clase sencilla en lenguaje Delphi que ilustra el concepto de propiedad pública para acceder a un campo privado.

interfaztype TStudent = class strict private FName : string ; procedure SetName ( const Value : string ) ; public /// <summary> /// Obtiene o establece el nombre del estudiante. /// </summary> property Name : string read FName write SetName ; end ;// ...implementaciónprocedimiento TStudent . SetName ( const Value : string ) ; begin FName := Value ; end ;fin .

En este ejemplo de una clase simple que representa a un estudiante con solo el nombre almacenado, se puede ver que la variable nombre es privada, es decir, solo visible desde la clase Student, y los métodos "setter" y "getter" son públicos, a saber, los métodos " getName()" y " setName(name)".

clase pública Estudiante { cadena privada nombre ;public String getName () { return name ; } public void setName ( String name ) { this . name = name ; } }

En este ejemplo, se utiliza una función constructora Studentpara crear objetos que representan a un estudiante, almacenando únicamente su nombre.

función Estudiante ( nombre ) { var _nombre = nombre ;this.getName = function ( ) { return _name ; } ;this.setName = function ( value ) { _name = value ; } ; }​

O (usando una forma obsoleta de definir accesores en navegadores web): ^{[ 8 ]}

función Estudiante ( nombre ){ var _nombre = nombre ; this . __defineGetter__ ( 'nombre' , function () { return _nombre ; }); this . __defineSetter__ ( 'nombre' , function ( valor ) { _nombre = valor ; }); }

O (usando prototipos para la herencia y la sintaxis de acceso de ES6 ):

función Estudiante ( nombre ){ este . _nombre = nombre ; }Estudiante.prototipo = { obtener nombre ( ) { devolver este . _nombre ; }, establecer nombre ( valor ) { este . _nombre = valor ; } } ;

O (sin usar prototipos):

var Estudiante = { obtener nombre () { devolver este . _nombre ; }, establecer nombre ( valor ) { este . _nombre = valor ; } };

O (usando defineProperty):

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

Utilizando la sintaxis tradicional de Objective-C 1.0, con conteo manual de referencias como el que funciona en GNUstep en Ubuntu 12.04 :

@interface Student : NSObject { NSString * _name ; }- ( NSString * ) nombre ; - ( void ) establecerNombre: ( NSString * ) nombre ;@fin@implementación Estudiante- ( NSString * ) nombre { return _nombre ; }- ( void ) setName: ( NSString * ) name { [ _name release ]; _name = [ name retain ]; }@fin

Utilizando la sintaxis más reciente de Objective-C 2.0, como la que se usa en Mac OS X 10.6 , iOS 4 y Xcode 3.2, se genera el mismo código que se describe anteriormente:

@interface Estudiante : NSObject@property ( nonatomic , retain ) NSString * nombre ;@fin@implementación Estudiante@synthesize nombre = _nombre ;@fin

Y a partir de OS X 10.8 e iOS 6 , al usar Xcode 4.4 o superior, la sintaxis se puede simplificar aún más:

@interface Estudiante : NSObject@property ( nonatomic , strong ) NSString * nombre ;@fin@implementación Estudiante//Aquí no se permite nada y está bien.@fin

paquete Estudiante ;sub nuevo { bendecir {}, cambiar ; }sub set_name { my $self = shift ; $self -> { name } = $_ [ 0 ]; }sub obtener_nombre { mi $self = shift ; return $self -> { nombre }; }1 ;

O bien, utilizando Class::Accessor

paquete Estudiante ; usar base qw(Clase::Accessor) ; __PAQUETE__ -> seguir_mejores_prácticas ;Estudiante -> mk_accessors ( qw(nombre) );1 ;

O bien, utilizando el sistema de objetos Moose :

paquete Estudiante ; usar Moose ;# Moose utiliza el atributo name como setter y getter, las propiedades reader y writer # nos permiten anular eso y proporcionar nuestros propios nombres, en este caso get_name y set_name tienen 'name' => ( is => 'rw' , isa => 'Str' , reader => 'get_name' , writer => 'set_name' );1 ;

PHP define los "métodos mágicos" __gety __setpara las propiedades de los objetos. ^{[ 9 ]}

En este ejemplo de una clase simple que representa a un estudiante con solo el nombre almacenado, se puede ver que la variable nombre es privada, es decir, solo visible desde la clase Student, y los métodos "setter" y "getter" son públicos, es decir, los métodos getName()y setName('name').

clase Estudiante { cadena privada $nombre ;/**  * @return string El nombre.  */ public function getName () : string { return $this -> name ; }/**  * @param string $newName El nombre a establecer.  */ public function setName ( string $newName ) : void { $this -> name = $newName ; } }

Este ejemplo utiliza una clase de Python con una variable, un método getter y un método setter.

clase Estudiante : _nombre : str# Inicializador def __init__ ( self , name : str ) -> None : # Una variable de instancia para almacenar el nombre del estudiante self . _name = name# Método getter @property def name ( self ) -> str : return self . _name# Método setter @name . setter def name ( self , new_name : str ) -> None : self . _name = new_name

estudiante : Estudiante = Estudiante ( "Bob" ) imprimir ( estudiante.nombre ) # imprime : Bobestudiante.nombre = "Alice " print ( estudiante.nombre ) # imprime : Aliceestudiante._nombre = " Charlie " # omitir el setter print ( estudiante._nombre ) # omitir el getter # imprime : Charlie

En Racket , el sistema de objetos es una forma de organizar el código que complementa los módulos y las unidades. Al igual que en el resto del lenguaje, el sistema de objetos tiene valores de primera clase y se utiliza el ámbito léxico para controlar el acceso a objetos y métodos.

#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"

Las definiciones de estructuras son una forma alternativa de definir nuevos tipos de valores, y los modificadores están presentes cuando se requieren explícitamente:

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

En Ruby , se pueden definir métodos de acceso y modificación individuales, o bien se pueden utilizar las construcciones de metaprogramación para declarar una variable privada en una clase y para proporcionar acceso público a ella, ya sea de solo lectura o de lectura y escritura, respectivamente.attr_readerattr_accessor

Definir métodos individuales de acceso y modificación crea espacio para el preprocesamiento o la validación de los datos.

clase Estudiante definición nombre @nombre findef nombre = ( valor ) @nombre = valor fin fin

Acceso público simple de solo lectura a @namela variable implícita

clase Estudiante attr_reader :nombre fin

Acceso público simple de lectura y escritura a @namela variable implícita

clase Estudiante attr_accessor :nombre fin

Este ejemplo ilustra el concepto de propiedades en VB.NET, que se utilizan en las clases. Al igual que en C#, se hace un uso explícito de los métodos Gety .Set

Estudiante de clase públicaPrivado _name como cadenaNombre de la propiedad pública () Obtener Devolver _nombre Fin Obtener Establecer ( Por valor valor ) _nombre = valor Fin Establecer Fin PropiedadFin de clase

En VB.NET 2010, las propiedades implementadas automáticamente permiten crear una propiedad sin necesidad de usar la sintaxis Get y Set. Cabe destacar que el compilador crea una variable oculta, denominada _name, que se corresponde con la propiedad name. Usar otra variable dentro de la clase con el mismo nombre _namegeneraría un error. El acceso privilegiado a la variable subyacente está disponible desde dentro de la clase.

Clase pública Estudiante Propiedad pública nombre Como Cadena Fin de clase