Property (programming)

<h2 id="support-in-languages">Support in languages</h2>
<p>Programming languages that support properties include <a href="/facts/ActionScript_3/xtDQb0wR">ActionScript 3</a>, <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>, <a href="/facts/D_(programming_language)/4qIzRjkF">D</a>, <a href="/facts/Object_Pascal/cuGkuISv">Delphi</a>/<a href="/facts/Free_Pascal/kmGChqAg">Free Pascal</a>, eC, <a href="/facts/F_Sharp_(programming_language)/jdXHnYz5">F#</a>, <a href="/facts/Kotlin_(programming_language)/CrAqIFLn">Kotlin</a>, <a href="/facts/JavaScript/XhhIIEsl">JavaScript</a>, <a href="/facts/Objective-C/5mM557BW">Objective-C 2.0</a>, <a href="/facts/Python_(programming_language)/YbuGqofa">Python</a>, <a href="/facts/Scala_(programming_language)/ebL8o6AK">Scala</a>, <a href="/facts/Swift_(programming_language)/A7qHQC32">Swift</a>, <a href="/facts/Lua_(programming_language)/xkBCgta0">Lua</a>, and <a href="/facts/Visual_Basic/7QMXM6fP">Visual Basic</a>.
</p><p>Some object-oriented languages, such as <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a> and <a href="/facts/C%252B%252B/Et0F2qn9">C++</a>, do not support properties, requiring the programmer to define a pair of <i><a href="/facts/Accessor_method/sKfxYzFM">accessor</a></i> and <i><a href="/facts/Mutator_method/sKfxYzFM">mutator</a></i> methods instead.<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a>
</p><p><a href="/facts/Oberon-2/ahBack6j">Oberon-2</a> provides an alternative mechanism using object variable visibility flags.
</p><p>Other languages designed for the <a href="/facts/Java_virtual_machine/l9Nzrsun">Java Virtual Machine</a>, such as <a href="/facts/Groovy_(programming_language)/vGAckbte">Groovy</a>, natively support properties.
</p><p>While <a href="/facts/C%252B%252B/Et0F2qn9">C++</a> does not have first class properties, they can be emulated with <a href="/facts/Operator_overloading/hRyHs4Qf">operator overloading</a>.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a>
</p><p>Also note that some C++ compilers support first class properties as language extensions.
</p>
<ul><li>In <a href="/facts/Microsoft_Visual_Studio/omNe6Lej">Microsoft Visual Studio</a>,<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a> <a href="/facts/GNU_Compiler_Collection/t07jh01k">GCC</a>, and <a href="/facts/LLVM/nPmcspQN">llvm/clang</a>,<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> the __declspec(property) creates properties similar to <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>.</li>
<li><a href="/facts/Borland_C%252B%252B/H4ojX2up">Borland C++</a> and <a href="/facts/C%252B%252BBuilder/293I0the">Borland/CodeGear/Embarcadero C++Builder</a> use the __property keyword.<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a></li></ul>
<p>In many object oriented languages properties are implemented as a pair of accessor/mutator methods, but accessed using the same syntax as for public fields. Omitting a method from the pair yields a <i>read-only</i> or an uncommon <i>write-only</i> property.
</p><p>In some languages with no built-in support for properties, a similar construct can be implemented as a single method that either returns or changes the underlying data, depending on the context of its invocation. Such techniques are used e.g. in <a href="/facts/Perl/fx31kjlT">Perl</a>. 
</p><p>Some languages (<a href="/facts/Ruby_(programming_language)/BeYSaPSR">Ruby</a>, <a href="/facts/Smalltalk/Ru2UPVDE">Smalltalk</a>) achieve property-like syntax using normal methods, sometimes with a limited amount of <a href="/facts/Syntactic_sugar/FYkNSdTI">syntactic sugar</a>.
</p>
<h2 id="syntax-variants">Syntax variants</h2>
<p>Some languages follow well-established syntax conventions for formally specifying and utilizing properties and methods.
</p><p>Among these conventions:
</p>
<ul><li>Dot notation</li>
<li>Bracket notation</li></ul>
<h3>Dot notation</h3>
<p>The following example demonstrates dot notation in JavaScript.
</p>
document.createElement('pre');

<h3>Bracket notation</h3>
<p>The following example demonstrates bracket notation in JavaScript.
</p>
document['createElement']('pre');

<h2 id="example-syntax">Example syntax</h2>
<h3>C#</h3>
class Pen 
{
    private int color; // private field
    
    // public property
    public int Color 
    {  
        get
        {
            return this.color;
        }
        set 
        {
            if (value > 0) {
                this.color = value;
            }
        }
    }
}

// accessing:
Pen pen = new Pen();
int color_tmp = 0;
// ...
pen.Color = 17;
color_tmp = pen.Color;
// ...
pen.Color = ~pen.Color; // bitwise complement ...

// another silly example:
pen.Color += 1; // a lot clearer than "pen.set_Color(pen.get_Color() + 1)"!

<p>Recent C# versions also allow "auto-implemented properties" where the backing field for the property is generated by the compiler during compilation. This means that the property must have a setter. However, it can be private.
</p>
class Shape 
{
    public int Height { get; set; }
    public int Width { get; private set; }
}

<p><a href="/facts/C%252B%252B/Et0F2qn9">C++</a> does not have first class properties, but there exist several ways to emulate properties to a limited degree. Two of which follow:
</p>
<h4>Using Standard C++</h4>
#include <iostream>

template <typename T> class property {
        T value;
    public:
        T & operator = (const T &i) {
            return value = i;
        }
        // This template class member function template serves the purpose to make
        // typing more strict. Assignment to this is only possible with exact identical types.
        // The reason why it will cause an error is temporary variable created while implicit type conversion in reference initialization.
        template <typename T2> T2 & operator = (const T2 &i) {
            T2 &guard = value;
            throw guard; // Never reached.
        }

// Implicit conversion back to T. 
        operator T const & () const {
            return value;
        }
};

struct Foo {
    // Properties using unnamed classes.
    class {
            int value;
        public:
            int & operator = (const int &i) { return value = i; }
            operator int () const { return value; }
    } alpha;

class {
            float value;
        public:
            float & operator = (const float &f) { return value = f; }
            operator float () const { return value; }
    } bravo;
};

struct Bar {
    // Using the property<>-template.
    property <bool> alpha;
    property <unsigned int> bravo;
};

int main () {
    Foo foo;
    foo.alpha = 5;
    foo.bravo = 5.132f;

Bar bar;
    bar.alpha = true;
    bar.bravo = true; // This line will yield a compile time error
                      // due to the guard template member function.
    ::std::cout << foo.alpha << ", "
                << foo.bravo << ", "
                << bar.alpha << ", "
                << bar.bravo
                << ::std::endl;
    return 0;
}

<p>Also see <a href="https://stackoverflow.com/a/5924594">Stack Overflow</a> for a more detailed example.
</p>
<h4>C++, Microsoft, GCC, LLVM/clang and C++Builder-specific</h4>
<p>An example taken from the MSDN <a href="http://msdn.microsoft.com/en-us/library/yhfk0thd.aspx">documentation page</a>.
</p>
// declspec_property.cpp
struct S
{
   int i;
   void putprop(int j)
   { 
      i = j;
   }

int getprop()
   {
      return i;
   }

__declspec(property(get = getprop, put = putprop)) int the_prop;
};

int main()
{
   S s;
   s.the_prop = 5;
   return s.the_prop;
}

<h3>D</h3>
class Pen
{
    private int m_color; // private field
    
    // public get property
    public int color () {
        return m_color;
    }
    
    // public set property
    public void color (int value) {
         m_color = value;
    }
}

auto pen = new Pen;
pen.color = ~pen.color; // bitwise complement

// the set property can also be used in expressions, just like regular assignment
int theColor = (pen.color = 0xFF0000);

<p>In D version 2, each property accessor or mutator must be marked with @property:
</p>
class Pen
{
    private int m_color; // private field
    
    // public get property
    @property public int color () {
        return m_color;
    }
    
    // public set property
    @property public void color (int value) {
        m_color = value;
    }
}

<h3>Delphi/Free Pascal</h3>
type TPen = class
  private
    FColor: TColor;
    function GetColor: TColor;
    procedure SetColor(const AValue: TColor);
  public
    property Color: Integer read GetColor write SetColor;
end;

function TPen.GetColor: TColor;
begin
  Result := FColor;
end;

procedure TPen.SetColor(const AValue: TColor);
begin
  if FColor <> AValue
   then FColor := AValue;
end;

// accessing:
var Pen: TPen;
// ...
Pen.Color := not Pen.Color;

(*
Delphi and Free Pascal also support a 'direct field' syntax -

property Color: TColor read FColor write SetColor;

property Color: TColor read GetColor write FColor;

where the compiler generates the exact same code as for reading and writing
a field. This offers the efficiency of a field, with the safety of a property.
(You can't get a pointer to the property, and you can always replace the member
access with a method call.)
*)

<h3>eC</h3>
class Pen 
{
   // private data member
   Color color;
public:
   // public property
   property Color color 
   {  
      get { return color; }
      set { color = value; }
   }
}
Pen blackPen { color = black };
Pen whitePen { color = white };
Pen pen3 { color = { 30, 80, 120 } };
Pen pen4 { color = ColorHSV { 90, 20, 40 } };

<h3>F#</h3>
type Pen() = class
    let mutable _color = 0

member this.Color
        with get() = _color
        and set value = _color <- value
end

let pen = new Pen()
pen.Color <- ~~~pen.Color

<h3>JavaScript</h3>
function Pen() {
    this._color = 0;
}
// Add the property to the Pen type itself, can also
// be set on the instance individually
Object.defineProperties(Pen.prototype, {
    color: {
        get: function () {
            return this._color;
        },
        set: function (value) {
            this._color = value;
        }
    }
});

var pen = new Pen();
pen.color = ~pen.color; // bitwise complement
pen.color += 1; // Add one

<h3>ActionScript 3.0</h3>
package {
	public class Pen {
		private var _color:uint = 0;
		
		public function get color ():uint {
			return _color;
		}
		
		public function set color(value:uint):void {
			_color = value;
		}
	}
}

var pen:Pen = new Pen();
pen.color = ~pen.color; // bitwise complement
pen.color += 1; // add one

<h3>Objective-C 2.0</h3>
@interface Pen : NSObject
@property (copy) NSColor *colour;	// The "copy" attribute causes the object's copy to be
					// retained, instead of the original.
@end

@implementation Pen
@synthesize colour;			// Compiler directive to synthesise accessor methods.
					// It can be left behind in Xcode 4.5 and later.
@end

<p>The above example could be used in an arbitrary method like this:
</p>
Pen *pen = [[Pen alloc] init];
pen.colour = [NSColor blackColor];
float red = pen.colour.redComponent;
[pen.colour drawSwatchInRect: NSMakeRect(0, 0, 100, 100)];

<h3>PHP</h3>
class Pen
{
    private int $color = 1;

function __set($property, $value)
    {
        if (property_exists($this, $property)) { 
            $this->$property = $value;
        }
    }

function __get($property)
    {
        if (property_exists($this, $property)) {
            return $this->$property;
        }
        return null;
    }
}

$p = new Pen();
$p->color = ~$p->color; // Bitwise complement
echo $p->color;

<h3>Python</h3>
<p>Properties only work correctly for new-style classes (classes that have object as a <a href="/facts/Superclass_(computer_science)/a7R1xv8n">superclass</a>), and are only available in Python 2.2 and newer (see <a href="https://www.python.org/download/releases/2.2/descrintro/#property">the relevant section of the tutorial <i>Unifying types and classes in Python 2.2</i></a>). Python 2.6 added a new syntax involving decorators for defining properties.
</p>
class Pen:
    def __init__(self) -> None:
        self._color = 0  # "private" variable

@property
    def color(self):
        return self._color

@color.setter
    def color(self, color):
        self._color = color

pen = Pen()
# Accessing:
pen.color = ~pen.color  # Bitwise complement ...

<h3>Ruby</h3>
class Pen
  def initialize
    @color = 0
  end
    
  # Defines a getter for the @color field
  def color
    @color
  end

# Defines a setter for the @color field
  def color=(value)
    @color = value
  end
end

pen = Pen.new
pen.color = ~pen.color    # Bitwise complement

<p>Ruby also provides automatic getter/setter synthesizers defined as instance methods of Class.
</p>
class Pen
  attr_reader :brand    # Generates a getter for @brand (Read-Only)
  attr_writer :size     # Generates a setter for @size  (Write-Only)
  attr_accessor :color  # Generates both a getter and setter for @color (Read/Write)

def initialize
    @color = 0          # Within the object, we can access the instance variable directly
    @brand = "Penbrand"
    @size = 0.7         # But we could also use the setter method defined by the attr_accessor Class instance method
  end
end

pen = Pen.new
puts pen.brand           # Accesses the pen brand through the generated getter
pen.size = 0.5           # Updates the size field of the pen through the generated setter
pen.color = ~pen.color

<h3>Visual Basic</h3>
<h4>Visual Basic (.NET 2003–2010)</h4>
Public Class Pen
 
    Private _color As Integer ' Private field

Public Property Color() As Integer ' Public property
        Get
            Return _color
        End Get
        Set(ByVal value As Integer)
            _color = value
        End Set
    End Property

End Class

' Create Pen class instance
Dim pen As New Pen()

' Set value
pen.Color = 1

' Get value
Dim color As Int32 = pen.Color

<h4>Visual Basic (only .NET 2010)</h4>
Public Class Pen

Public Property Color() As Integer ' Public property

End Class

' Create Pen class instance
Dim pen As New Pen()

' Set value
pen.Color = 1

' Get value
Dim color As Int32 = pen.Color

<h4>Visual Basic 6</h4>
' in a class named clsPen
Private m_Color As Long

Public Property Get Color() As Long
    Color = m_Color
End Property

Public Property Let Color(ByVal RHS As Long)
    m_Color = RHS
End Property

' accessing:
Dim pen As New clsPen
' ...
pen.Color = Not pen.Color

<h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Attribute_(computing)/EpQSmn02">Attribute (computing)</a></li>
<li><a href="/facts/Bound_property/qp1TkWzk">Bound property</a></li>
<li><a href="/facts/Field_(computer_science)/jt622EDb">Field (computer science)</a></li>
<li><a href="/facts/Indexer_(programming)/t6gNGP4Q">Indexer (programming)</a></li>
<li><a href="/facts/Method_(computer_programming)/8kAXxVYs">Method (computer programming)</a></li>
<li><a href="/facts/Mutator_method/sKfxYzFM">Mutator method</a></li>
<li><a href="/facts/Uniform_access_principle/xgC9qBW7">Uniform access principle</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"Accessors And Mutators In Java". C# Corner - Community of Software and Data Developers. Retrieved 5 January 2022. <a href="https://www.c-sharpcorner.com/UploadFile/3614a6/accessors-and-mutators-in-java/" target="_blank">https://www.c-sharpcorner.com/UploadFile/3614a6/accessors-and-mutators-in-java/</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"Portability of Native C++ properties". Stack Overflow. Stack Overflow. Retrieved 5 January 2022. <a href="https://stackoverflow.com/questions/5772480/portability-of-native-c-properties" target="_blank">https://stackoverflow.com/questions/5772480/portability-of-native-c-properties</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"property (C++)". Microsoft technical documentation. Microsoft. Retrieved 5 January 2022. <a href="https://docs.microsoft.com/en-us/cpp/cpp/property-cpp?view=msvc-170" target="_blank">https://docs.microsoft.com/en-us/cpp/cpp/property-cpp?view=msvc-170</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"clang::MSPropertyDecl Class Reference". Clang: a C language family frontend for LLVM. Retrieved 5 January 2022. <a href="https://clang.llvm.org/doxygen/classclang_1_1MSPropertyDecl.html" target="_blank">https://clang.llvm.org/doxygen/classclang_1_1MSPropertyDecl.html</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>"__property Keyword Extension". Embarcadero/IDERA Documentation Wiki. Retrieved 5 January 2022. <a href="https://docwiki.embarcadero.com/RADStudio/Sydney/en/Property" target="_blank">https://docwiki.embarcadero.com/RADStudio/Sydney/en/Property</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
</ol>

Property (programming) open-in-new

Property (programming)