标签: getter-setter

我的目标是在类中更改值时触发事件接收器.我的解决方案是使用get和set函数.但是,我不希望在读取值时出现任何性能问题.在下面的课程中:

class Vertex {
 public:
  const double& GetX() { return _x; } // should inline automatically
  const double& GetY() { return _y; } // ' '                     ' '
  void SetX(const double& x); // complex stuff in source file
  void SetY(const double& y); // ' '                      ' '
 private:
  double _x, _y;
}

我把getter的定义放在头文件中,因为这应该允许它们被内联.

我的问题是:有什么方法可以在更改值时自动调用函数,而不需要在头文件中包含函数定义？或者是否有可见性级别允许任何人读取数据,但只有类本身才能修改它？或者别的什么？

我知道另一种方法是手动调用更新函数,但这看起来很难看:

vertex.X = 5;
vertex.Update();

先感谢您.

编辑:

到目前为止,我听到了一些很棒的答案.解决方案取决于您的目标:

• 容易:吸气剂和二传手; 虽然不是很干净.
• 清洁:属性类(或代理); 实现运营商并不是那么容易.

但是,效率怎么样？

我刚刚为我之前推测的单独的读/写访问权限制定了一个很好的技巧:

class Vertex {
 public:
  Vertex(double x, double y)
      : _x(x), _y(y), X(_x), …

我有三个java文件(Login.java,Sales.java),我想将一个变量"Username"传递给其他3个java文件,以便Sales.java可以显示"用户名"

这就是我所做的,构建一个loginstaff.java:

public class LoginStaff {
    private String Username;
    public void LoginStaff() {
    }
    public void LoginStaff(String Username) {
        this.Username = Username;
    }
    public String getUsername() {
        return this.Username;
    }
    public void setUserame(String Username) {
        this.Username = Username;
    }
}

在Login.java中

...
String login = tfusername.getText();
LoginStaff loginstaff = new LoginStaff();
loginstaff.setUserame(login);
...

在Sales.java中 ... LoginStaff loginstaff = new LoginStaff(); 的System.out.println(loginstaff.getUsername()); ...

问题是我无法在Sales中获取用户名,它返回"null".我知道这是与不同类中的新对象相关的东西,但我不知道如何解决这个问题.

我正在尝试创建一个对象,该对象自动为对象的新实例定义getter/setter.我希望setter将值放在一个名为newValues的单独对象属性中.为什么在下面的代码片段中设置prop1的值实际设置了newValues.prop2的值而不是newValues.prop1？

我在这做傻事吗？这完全有可能因为我只睡了几个小时...... :)

var Record = function(data) {
  this.fieldValues = {}
  this._data = data;
  var record = this;
  for(var key in data) {
    record.__defineGetter__(key, function() {
      return record._data[key];
    });
    record.__defineSetter__(key, function(val) {
      record.fieldValues[key] = val;
    });
  }
}

var myRecord = new Record({prop1: 'prop1test', prop2: 'prop2test'});

myRecord.prop1 = 'newvalue';

console.log(myRecord.fieldValues.prop1); // undefined
console.log(myRecord.fieldValues.prop2); // 'newvalue'

可能重复:
访问者应该返回值还是常量引用？

首先,让我们忽略制定者和吸气者不是邪恶的.:)

我的问题是,如果我有一个std::容器作为成员的类,让我们说string,getter的返回类型应该是什么？我有点喜欢const T&相比,T性能方面的原因......我知道,大多数时候用户做一个拷贝反正,但我想不是所有的时间.我错了吗？

所以一般情况更好:

std::string get_name() const;

要么

const std::string& get_name() const;

我正在尝试创建一个动态构建自己的getter和setter的对象:

function Person( properties ) { // 'properties' is an object literal

    this._private = properties; // private by convention

    for ( key in this._private ) {

        this[key] = function() {

            return this._private[key];
        }
    }
}

我希望,这会产生这样的东西:

var jack = new Person({

    working:true,
    age:33,
    gender:'male'
});

jack.working() --> true
jack.age() --> 33
jack.gender() --> 'male'

问题是,它总是返回'男性',如下所示:

jack.working() --> 'male'
jack.age() --> 'male'
jack.gender() --> 'male'

我错过了什么？哦,这只是一个概念证明.我知道这不是用JavaScript创建getter和setter的完美解决方案.

在另一页上看到这个:

"使用getter,可以获得@a的当前值,而无需修改它."

"使用setter,one修改@a,并将其新值作为返回值."

但是,从cancan wiki查看这段代码,我发现setter和getter实际上都在为它中的变量做些什么.

def roles=(roles)
  self.roles_mask = (roles & ROLES).map { |r| 2**ROLES.index(r) }.inject(0, :+)
end

def roles
  ROLES.reject do |r|
    ((roles_mask || 0) & 2**ROLES.index(r)).zero?
  end
end

看起来getter实际上是返回一个真值,如果不是,那么至少是某种变换.那么这个"getters得到了没有修改,setter设置与修改"规则实际上是真的吗？

如何在两个不同的类中使用getter setter

Class A{

    int a = 10;
    GetterAndSetter gs = new GetterAndSetter();
    gs.setValue(a);
}


Class GetterAndSetter {
    int a ;
    public void setValue(int a){
    this.a = a;
}

public int getValue(){

return a;

   }

}


class B {

    int c;
    GetterAndSetter gs = new GetterAndSetter();
    c = gs.getValue();
}

打印时,它给出null.并告诉我它是否有效.

我有类,使用相同的getter共享相同的属性,但是不同的setter.作为一个简单,无用的例子,类似于:

class Spam():
    @property
    def foo(self):
        return self.bar

    @foo.setter
    def foo(self, foo):
        self.bar = foo


class Eggs(Spam):
    @foo.setter
    def foo(self, foo):
        self.bar = ' '.join(['Egg\'s foo:', foo])

但是,尝试运行此模块会引发以下错误:

Traceback (most recent call last):
  File "./test.py", line 13, in <module>
    class Eggs(Spam):
  File "./test.py", line 14, in Eggs
    @foo.setter
NameError: name 'foo' is not defined

为了使这项工作符合要求,我需要重新定义Eggs.foo:

class Eggs(Spam):
    @property
    def foo(self):
        return super().foo

    @foo.setter
    def foo(self, foo):
        self.bar = ' '.join(['Egg\'s foo:', foo])

有没有办法避免重新定义属性？因为如果你像我这样在几个子类中有很多这样的getter和setter,这非常烦人.

我尝试通过扩展运算符语法在getter中创建混合到JS对象中,但它似乎总是返回null.

HTML:

<body>
  <div id="wrapperA"></div>
  <div id="wrapperB"></div>
</body>
<script src='./test.js'></script>

JS:

"use strict";

const mixin = {
    get wrapper() { return document.getElementById(this.wrappername); }
}

const wrapperA = {
  wrappername: 'wrapperA',
  ...mixin
}

const wrapperB = {
  wrappername: 'wrapperB',
  ...mixin
}

console.log(wrapperA);
console.log(wrapperB);

控制台输出:

{wrappername: "wrapperA", wrapper: null}
{wrappername: "wrapperB", wrapper: null}

这链接到一个应该工作的扩展函数,从我可以告诉上面的代码创建一个无意的闭包.但是,与...语法相比,它的读取效果非常差.有人知道如何让代码与后一种解决方案一起使用吗？ES开发者是否知道这个问题并将在ES7中修复？

我正在尝试制作一个相当基本的程序但是我得到了一些非常不一致的输出.特别是setter似乎没有设置值,虽然当我以不应该改变输出的方式混淆参数变量时,我有时会得到工作结果.

这是我的代码:

point.cpp

public:

point()
{
    x = 0;
    y = 0;
}
point(double x, double y)
{
    x = x;
    y = y;
}
void set_x(double x)
{
    x = x;
}
void set_y(double y)
{
    y = y;
}
double get_x() const
{
    return x;
}
double get_y() const
{
    return y;
}
private:
double x;
double y;
};

主要

point pointA;
double x,y;

cout << "Enter x value for point A: " << endl;
cin >> x; …