Ruby'de bunun mümkün olduğunu çok garip buluyorum (hemen nasıl söyleyemem):

obj = #code redacted

print obj.state # Some value.

LValue = obj

print obj.state # Different value!

Buradaki zorluk, kabaca bu formdan kod oluşturmaktır. Bir nesne oluşturun ve onu bir değişkene atayın. stateYukarıda belirtildiği gibi, tanımlamak için hala eski tanımlayıcıyı ( yukarıda) kullanıyor olsanız bile , nesnenin yeni bir tanımlayıcıya ( LValueyukarıda) atanmasından sonra değişen, yukarıda belirtilen gibi belirli bir özniteliği (veya deterministik, idempotent yöntemi) olmalıdır .obj

Vurgu için düzenleme : stateveya eşdeğeri kesin olmalıdır, bu nedenle değeri değiştiren bir erişimci oluşturmak veya herhangi bir nedenden dolayı arka arkaya birkaç kez çağrıldığında farklı sonuçlar döndürmek geçerli bir çözüm değildir. Veya daha basit haliyle, durumu değiştiren görev olmalıdır.

Tamamen meşru bir çözüm bulunmayan yerlerde muhtemelen bir kısmı olmasına rağmen, ataması olan herhangi bir dil uygundur. Birkaç gün sonra kimse cevap vermezse, Ruby cevabımı göndereceğim ve en yüksek oyu alan cevapları yuvarlanma esasına göre kabul ediyorum.

C ++

Bu doğru araçları kullanarak çok önemlidir.

#include <iostream>

using namespace std;

class Obj {
public:
   int state;

   Obj& operator= (Obj& foo) {
      foo.state++;
      this->state = foo.state - 2;
      return *this;
   }
};

int main() {
   Obj a, b, c, d;
   a.state = 3;
   b.state = 4;

   cout << a.state << " " << b.state << "\n";

   c = a;
   d = b;

   cout << a.state << " " << b.state << " " << c.state << " " << d.state << "\n";

   return 0;
}

Çıktı:

3 4
4 5 2 3

PHP (hata ayıklama yapısı,> = 5.4)

Bir alıcıda nesnenin refcount değerini kullanırız. (Yani, ödev ile, yeniden sayım artar ve değer değişir)

class State {
    public function __get($arg) {
        ob_start();
        debug_zval_dump($this); // e.g. "object(State)#1 (0) refcount(6)"
        return ob_get_clean()[29];
    }
}

$obj = new State;
var_dump($obj->state);
$a = $obj;
var_dump($obj->state);

C #

İki basit seçenek:

class Obj
{
    public int state;
    public static implicit operator int(Obj o)
    {
        return o.state++;
    }
}

static int LValueI;
static Obj LValueM { set { value.state++; } }
static void Main()
{
    var obj = new Obj { state = 1 };
    LValueI = obj;
    Console.WriteLine(obj.state); //2, caused by the implicit cast.

    LValueM = obj;
    Console.WriteLine(obj.state); //3, caused by the property setter.
    Console.ReadLine();
}

Ya da sadece aynı hafızaya yazabiliriz:

[StructLayoutAttribute(LayoutKind.Explicit)]
class Program
{
    [FieldOffset(0)]
    int state = 1;
    [FieldOffset(1)]
    int LValue;

    void Test()
    {
        var obj = this;

        Console.WriteLine(state);  //1
        LValue = state;
        Console.WriteLine(state);  //257
        Console.ReadLine();
    }
    static void Main() { new Program().Test(); }
}

TeX, buradaki diğer cevaplardan çok daha kısa

\setbox0=\hbox{Hello world!} % Put stuff in the box 0.
\message{\the\wd0}           % Print the width of the box => non-zero
\setbox2=\box0               % Put the box instead in box 2.
\message{\the\wd0}           % Now box 0 is void, hence has zero width.

Bir dizgi sistemi olarak, TeX, dizgi malzemesini içeren bir "kutu" tipine sahiptir. En yaygın kullanım durumu, bu materyali hareket ettirmek, kopyalamak yerine vb. Ayırmak olduğundan, kullanıldığında kutular normalde silinir (veya "kutu" değişkenleri işaretçilerdir ve bir seferde yalnızca bir işaretçi gösterebilir. bellekteki gerçek bir kutuya). Sihire gerek yok.

C ++ 11 (Yani, benzersiz_ptr / shared_ptr :-) 'ı unutmuşsunuzdur)

#include <iostream>
#include <memory>
using namespace std;
int main() {
    std::unique_ptr<int> u1(new int(0)), u2;
    std::shared_ptr<int> s1 = std::make_shared<int>(0), s2;
    std::cout<<u1.get()<<" "<<u2.get()<<" "<<std::endl;
    std::cout<<s1.use_count()<<" "<<s2.use_count()<<" "<<std::endl;
    u2 = std::move(u1);
    s2 = s1;
    std::cout<<u1.get()<<" "<<u2.get()<<" "<<std::endl;
    std::cout<<s1.use_count()<<" "<<s2.use_count()<<" "<<std::endl;
   return 0;
}

Fortran 03

Bu, Hugo'nun D cevabına biraz benziyor, ancak biraz daha gizli (kısmen # $% ^ 'ın Nesneye Yönelik Fortran'ı bildiği için)?

module objects
   implicit none

   type ObjDef
      integer :: state
    contains
      procedure :: initObject
      procedure :: printObject
      procedure :: setNew
   end type
 contains
   subroutine initObject(this)
     class(ObjDef) :: this
     this%state = this%state + 1
   end subroutine initObject

   subroutine printObject(this)
     class(ObjDef) :: this
     print '(a,i0)',"this%state = ",this%state
   end subroutine printObject

   subroutine setNew(this,that)
     class(ObjDef) :: this,that
     that%state = this%state
   end subroutine setNew

end module objects

program objectChange
   use objects
   type(ObjDef) :: a,b

   call initObject(a)
   call printObject(a)
   call b%setNew(a)
   call printObject(a)
end program objectChange

Çıktı

this%state = 1
this%state = 0

Neler olduğunu çözebilirsen, bonus sana işaret ediyor! Değilse:

Prosedürü çağrılırken setNewşeklinde call b%setNew(a), bdolaylı İlk argüman değil, ikinci sırada.

Güç kalkanı

Bu, stateözelliği, nesneye işaret eden değişkenlerin adları olan bir nesne oluşturur .

$a = @{}| Add-Member -MemberType:16 -PassThru state -Value {
        (gv|?{$this -eq $_.Value}|%{$_.Name}) -join ','} 

'Before: ' + $a.state
$b = $a
'After: ' + $a.state

Çıktı

Before: a,this
After: a,b,this

Not: Atama bir çocuk kapsamında gerçekleşiyorsa, bu işe yaramaz.

'Before: ' + $a.state
&{$b = $a}
'After: ' + $a.state

çıktılar

Before: a,this
After: a,this

Perl 5

İşte Perl'de yapmanın bir yolu:

package Magic {
    sub new { bless {state => 1} }
    use overload '""' => sub { $_[0]{state}++ };
}
use feature 'say';

my $obj = new Magic;
say $obj->{state};
substr($_, 0) = $obj;
say $obj->{state};

Bu çıktılar:

1
2

Açıklama:

Bu basit bir aşırı yükleme uygulamasıdır . Özellikle, aşırı ""yüklenmiş nesne atandığında çağrılan dize dönüştürme işlecini aşırı substr()yüklüyorum (ki bu, evet, Perl'de yasal bir değerdir).

Ayrıca Perl'de kendilerine atanan her şeyi dizeleyen çok sayıda özel değişken vardır. Örneğin, aşağıdakiler de işe yarar:

my $obj = new Magic;
say $obj->{state};
$0 = $obj;
say $obj->{state};

Alternatif çözüm

İşte bunun başka bir yolu:

package Magic {
    use Devel::Peek 'SvREFCNT';
    sub new { bless \my $foo }
    sub state { SvREFCNT ${$_[0]} }
}
use feature 'say';

my $obj = new Magic;
say $obj->state;
my $other = $obj;
say $obj->state;

Burada, statetam anlamıyla nesneye referans sayısını sayan bir yöntemdir (onu daha fazla bağlanma / aşırı yük shenaniganlarıyla bir öznitelik yapabiliriz, ancak işleri karmaşık hale getirir). Bu nedenle, ilk çözümden farklı olarak $obj, durum değişikliği yapmak için bir nesne referansını tutabilecek normal bir değişkene atamanız gerekir.

JavaScript

Tamam, bu yüzden SSCCE olarak çalışan daha kısa bir sürüm yaptım, ancak artık JavaScript'i düzgün bir şekilde ayrıştırmaya çalışmıyorum, bu nedenle referans sayımı daha karmaşık bir komut dosyası içine yerleştirildiğinde çalışmayabilir.

(function run () {
    var lineOne = getLine (1), a, b, x, y, z;
    var x = {
        get state () {
            var x=/([a-z]+)\s*=\s*([a-z]+)/,c;
            return 1 + Object.keys (c = run.toString ().split ('\n').slice (0,getLine (2)).filter (function (a) {return (x.test (a))}).reduce (function (a,b,c,d) {var r=b.match (x),t=r[2];while (a[t]){t=a[t]};a[r[1]]=t;return a}, {v:0})).reduce (function (a,b) {return (c[b]=="x"?1:0) + a},0)
        }
    };
    console.log (x.state);  //1
    console.log (x.state);  //1
    y = x;
    console.log (x.state);  //2
    z = y;
    console.log (x.state);  //3    
    a = z;
    b = a;
    console.log (x.state);  //5
    a = null;
    console.log (x.state);  //4
    b = null;
    console.log (x.state);  //3
})() //1 1 2 3 5 4 3 

function getLine(n) {
   try {
      to
   } catch (dat) {
      var stack = dat.stack.split('\n');
       for (var i = 0; i < stack.length; i++) {
           if (~stack[i].indexOf ('getLine')) break;          
       }
      return dat.stack.split ('\n')[i + ~~n].match (/:(\d+)/)[1] - ~~window.hasOwnProperty ('__commandLineAPI')
   }
}

piton

Biraz hile yapıyor, ama nasıl:

import gc
class A(object):
    @property
    def state(self):
        return len(gc.get_referrers(self))

a = A()
print a.state
b = {"x": a}
print a.state
a.y = a
print a.state
del a
print b["x"].state

C ++ 11

bu örtük / açık destrucorları destekleyen diğer diller için uzatılabilir

#include <iostream>
using namespace std;

class Foo {
    int *ptr;
public:
    Foo() {
        ptr = new int(0);
    }   
    int state() {
        return *ptr;
    }
    ~Foo() {
        (*ptr)++;
    }
};
int main() {
    Foo a, b;
    cout << a.state() << " " << b.state() << "\n";
    {
        Foo c, d;
        c = a;
        d = b;
    }
   cout << a.state() << " " << b.state()  << "\n";

   return 0;
}

Varsayılan atama operatörü sığ bir kopya gerçekleştirir. Dolayısıyla alıcı nesne hala işaretçiye sahiptir ve herhangi bir değişiklik orijinal nesneyi örtük olarak etkiler;

Scala

Örtük dönüştürmeler, normal bir yerel değişkene atarken bunu gerçekleştirmenize izin verir:

import scala.language.implicitConversions

class Obj {
  var counter = 0
}

implicit def o2s(x: Obj): String = {
  x.counter += 1
  x.toString
}

val obj = new Obj
println(obj.counter)
val s: String = obj
println(obj.counter)

Bunu da çıkarılan tiplerle başarabilirsiniz:

var s = ""
s = obj

L-değerinin bir alan olmasını gerektirse de, özel bir ayarlayıcı yöntemi de kullanabilirsiniz:

object L {
  var _value = new Obj
  def value = _value
  def value_=(x: Obj): Unit = {
    _value = x
    x.counter += 1
  }
}

val obj = new Obj
println(obj.counter)
L.value = obj
println(obj.counter)

D

struct Obj {
    int state;

    void opAssign (ref Obj other) {
        ++other.state;
    }
}

void main () {
    import std.stdio;

    Obj obj, lvalue;
    writeln(obj);
    lvalue = obj;
    writeln(obj);
}

Çıktı:

Obj(0)
Obj(1)

Yakut

Söz verdiğim gibi, işte soruyu ilham alan cevap.

obj = Class.new { def self.state; to_s[/</] ? "Has not been assigned\n" : "Assigned to #{to_s}"; end }

print obj.state

LValue = obj

print obj.state

Class.newanonim bir sınıf oluşturur. to_sAnonim bir sınıfa çağrı yapmak , benzeyen nesnelerin varsayılan dize gösterimini sağlar #<Class:0x007fe3b38ed958>. Bununla birlikte, sınıf bir sabite atandığında, to_so sabit olur. Ruby'de sabit, büyük harfle başlayan bir değişkendir, dolayısıyla objadsız kalmasına izin veren sınıfa bir referanstır.

Kodum to_sbir stateyöntemde tamamlanıyor, böylece çıktı

Has not been assigned
Assigned to LValue

Buradaki çözümlerin çoğundan farklı olarak, bu yalnızca bir kez çalışır: atama obj başka bir sabite , dize temsilini değiştirmez ve hiçbiri de yeni bir değer atamaz LValue.

Java’da

Java'da bunun imkansız olduğunu düşündüm. Fakat…

Ana sınıf :

public class MyAppOfCats {

  public static void main(String[] args) {
    Cat tom = new Cat();
    System.out.println(tom.state()); 
    // Output : NOT-BEST-CAT
    Cat.bestCat = tom;
    System.out.println(tom.state());
    // Output : BEST-CAT
  }

}

Sınıf Kedisi:

public class Cat {

  static Cat bestCat;

  public Cat() {
    super();
  }

  public String state() {
      return ((this == Cat.bestCat) ? "BEST-CAT" : "NOT-BEST-CAT");
  }

}

@Tbodt'tan ilham aldım.

C ++

Bu davranış aslında standartta belirtilmiştir (ve bu yüzden kullanımdan kaldırılmıştır).

#include<iostream>
#include<memory>
int main()
{
    std::auto_ptr<int> a(new int(0));
    std::cout<<a.get()<<'\n';
    std::auto_ptr<int> b = a;
    std::cout<<a.get()<<'\n';
}

Çıktı

some address
0

Buna neden olan süreç Abhijit'in cevabı std::moveile aynıdır ancak marinus cevabı gerektirmeden aynıdır, fakat kendim tanımlamak yerine standart bir sınıf kullanmaktır.

Düzenleme: Bazı açıklamalar ekliyorum. Çıktıda, "bazı adres" aslında tahsis edilmiş tamsayının adresi için onaltılık bir değer olacaktır. std::auto_ptrbaşkasına atandığında mağaza işaretçisini serbest bırakır ve auto_ptrdahili işaretçisini 0 değerine ayarlar get().

piton

import sys
class K:state = property(sys.getrefcount)

Python 2.x

Fazladan bir sınıf tanımlamaksızın bunu yapmanın uygun bir yolunu bulamadım.

class State(object):
    def __init__(self):
        self.state = 0
    def __set__(self, obj, other):
        # Keep different references
        other.state += 1
        self.state += 2

class Program(object):
    obj, value = State(), State() # Create two State-objects
    def __init__(self):
        print "Before assignment:", self.obj.state, self.value.state # 0 0
        self.value = self.obj # Set value to obj (supposedly)
        print "After  assignment:", self.obj.state, self.value.state # 1 2
        self.value = self.obj
        print "2nd    assignment:", self.obj.state, self.value.state # 2 4

Program()

Java

Diğer tüm çözümler, dillerinin operatör aşırı yüklemesi biçimini kullanır. Java'da operatörün aşırı yüklenmesi yok, bu yüzden sıkışıp kaldığımı sanıyordum. Ama bir şey buldum.

İşte ana sınıf:

public class Program {
    public static void main(String[] args) {
        Thing thing = new Thing(0);
        System.out.println(thing.getState());
        Thing.otherThing = thing;
        Thread.sleep(1);
        System.out.println(thing.getState());
    }
}

Birkaç şüpheli satır var, ancak Thingsınıf tamamen normal olsaydı hiçbir şey yapmazlardı . Bu değil:

public class Thing {
    private int state;

    public Thing(int state) {
        this.state = state;
    }

    public int getState() {
        return state;
    }

    // Please do your best to ignore the rest of this class.
    public static volatile Thing otherThing;
    static {
        Thread t = new Thread() {
            public void run() {
                Thing t = otherThing;
                while (true)
                    if (t != otherThing) {
                        t = otherThing;
                        t.state++;
                    }
            }
        };
        t.setDaemon(true);
        t.start();
    }
}

İş parçacığı nedeniyle çalışması garanti edilmiyor, ancak JDK 1.8u5'te test ettim ve orada çalışıyor.

Ortak Lisp

Durumu bir vektöre bağlı özel değişkenlerin sayısı olarak tanımlarım. Böylece, özel bir değişkene atama durumu değiştirir.

(defgeneric state (object)
  (:documentation "Get the state of this object."))

(defmethod state ((object vector))
  ;; The state of a vector is the number of symbols bound to it.
  (let ((count 0))
    ;; Iterate each SYM, return COUNT.
    (do-all-symbols (sym count)
      ;; When SYM is bound to this vector, increment COUNT.
      (when (and (boundp sym) (eq (symbol-value sym) object))
    (incf count)))))

(defparameter *a* #(this is a vector))
(defparameter *b* nil)
(defparameter *c* nil)

(print (state *a*))
(setf *b* *a*)
(print (state *a*))
(print (state *a*))
(setf *c* *a*)
(print (state *a*))

Çıktı:

1 
2 
2 
3 

Yalnızca özel değişkenlere, sözcüksel değişkenlere veya bir nesnenin içindeki yuvalara yapılan atamalarla çalışır.

Dikkat et do-all-symbolsTüm paketlerde , bu nedenle paketi olmayan değişkenleri özlüyor. Birden fazla pakette bulunan sembolleri (bir paket başka bir paketten içe aktardığında) iki katına çıkartabilir.

Yakut

Ruby neredeyse aynı, ancak durumu bir diziye atıfta bulunulan sabit sayısı olarak tanımlıyorum.

class Array
  # Get the state of this object.
  def state
    # The state of an array is the number of constants in modules
    # where the constants refer to this array.
    ObjectSpace.each_object(Module).inject(0) {|count, mod|
      count + mod.constants(false).count {|sym|
        begin
          mod.const_get(sym, false).equal?(self)
        rescue NameError
          false
        end
      }
    }
  end
end

A = %i[this is an array]
puts A.state
B = A
puts A.state
puts A.state
C = A
puts A.state

Çıktı:

state-assign.rb:9:in `const_get': Use RbConfig instead of obsolete and deprecated Config.
1
2
2
3

Bu, histokratın , sınıf ya da modül olmayan Ruby nesnelerine vermiş olduğu cevabın genelleştirilmesidir . Config sabiti, uyarıyı yapan bazı kodu otomatik olarak yüklediği için uyarı belirir.

C ++

Sonuç farklı platformlarda farklılık gösterebilir. İdeone üzerinde test edilmiştir .

#include <iostream>
#include <cassert>
// File format: [ciiiiciiii...] a char (1 byte) followed by its state (4 bytes)
// Each group takes 5 bytes
char Buffer[30]; // 5*6, six groups

struct Group {
    char c;
    int state;
};

int main(void) {
    assert(sizeof(char) == 1);
    assert(sizeof(int) == 4);

    Group& first_group = *(Group*)(&Buffer[0]); // Group 1 is at 0
    Group& second_group = *(Group*)(&Buffer[5]); // Group 2 is at 5

    first_group.c = '2';
    first_group.state = 1234;

    std::cout << first_group.state << std::endl;

    second_group = first_group;

    std::cout << first_group.state << std::endl;

    return 0;
}

Çıktı:

1234
13010

C #

class A
{
    public int N { get; set; }
    public override string ToString() { return N.ToString(); }
}
class B
{
    public int N { get; set; }
    public override string ToString() { return N.ToString(); }
    public static implicit operator A(B b) { b.N = -b.N; return new A { N = b.N }; }
}
public static void Test()
{
    A a = new A { N = 1 };
    B b = new B { N = 2 };
    Console.WriteLine("a is {0}, b is {1}", a, b);
    Console.WriteLine("a is {0}, b is {1}", a, b);
    a = b;
    Console.WriteLine("a is {0}, b is {1}", a, b);
    Console.WriteLine("a is {0}, b is {1}", a, b);
}

Çıktı:

a is 1, b is 2
a is 1, b is 2
a is -2, b is -2
a is -2, b is -2