Mirror of forum.nim-lang.org

880 :: Getting a reference to object's field

• bozaloshtsh (orginal) [2015-02-16T16:13:11+01:00] view original

  How can I get a reference to the field in this example?

  type
    Test = object
      ok: seq[int]
  
  proc getOk(x: Test): seq[int] =
    x.ok
  
  var x = Test(ok: @[])
  
  var ok = x.getOk()
  ok.add(3)
  
  echo x.ok
  Run

  Instead of printing

  @[3]
  Run

  it prints

  @[]
  Run

  because the var statement apparently copies the value. How can I get a reference instead?

---

• jboy (orginal) [2015-02-16T16:34:02+01:00] view original

  Yes, the var statement copies the value.

  The following code will result in @[3] being printed:

  
  type
    Test = object
      ok: seq[int]
  
  proc getOk(x: var Test): var seq[int] =
    x.ok
  
  var x = Test(ok: @[])
  
  x.getOk().add(3)
  
  echo x.ok
  Run

  I made 2 changes to your code:

  1. proc getOk now takes a var parameter and returns a var return value.
  2. .add(3) directly to the return value from getOk() rather than saving it to a new var variable (which would make a copy of the return value).

  Does this answer your question?

---

• bozaloshtsh (orginal) [2015-02-16T16:43:14+01:00] view original

  Well, not entirely. I want to save it in a variable because in my real program I'm returning it from a function and then doing some complex transformations on it; I need to access the reference many times. Is it necessary to call the proc every time I want a reference?

---

• def (orginal) [2015-02-16T16:49:07+01:00] view original

  You can use untraced ptr or traced ref:

  type
    Test = object
      ok: seq[int]
  
  proc getOk(x: var Test): ptr seq[int] = addr x.ok
  
  var x = Test(ok: @[])
  var ok = x.getOk()
  ok[].add(3)
  
  echo x.ok
  Run

  type
    Test = object
      ok: ref seq[int]
  
  proc getOk(x: Test): ref seq[int] = x.ok
  
  proc newTest: Test =
    new result.ok
    result.ok[] = @[]
  
  var x = newTest()
  var ok = x.getOk()
  ok[].add(3)
  
  echo x.ok[]
  Run

---

• bozaloshtsh (orginal) [2015-02-16T16:52:46+01:00] view original

  The first one is what I want. Are there any major drawbacks of using a ptr, anything I should know? Even after reading the manual I don't fully understand the differene between refs and ptrs.

---

• OderWat (orginal) [2015-02-16T16:55:34+01:00] view original

  Isn't the second version of @def also possible just like this:

  type
    Test = object
      ok: ref seq[int]
  
  proc newTest: Test =
    result.ok = new seq[int]
    result.ok[] = @[]
  
  var x = newTest()
  var ok = x.ok
  ok[].add(3)
  
  echo x.ok[]
  
  Run

---

• def (orginal) [2015-02-16T16:58:12+01:00] view original

  Isn't the second version of @def also possible just like this:

  Right, thanks. Don't even need the getOk() proc anymore.

  Are there any major drawbacks of using a ptr, anything I should know?

  When the object disappears, the ok's memory will get garbage collected even though you still hold a ptr to it. Your ptr is then invalid and you will get invalid results or a segfault. With a ref the seq will only be garbage collected once no references to it remain.

---

• Stefan_Salewski (orginal) [2015-02-16T17:04:43+01:00] view original

  I have still no idea what this code from the first example does:

  proc getOk(x: Test): seq[int] =
    x.ok
  Run

  Should creates a sequence but is that "x.ok" the same as "result = x.ok" in this case. And what do we get, a new sequence, or the old from x object? I wonder that it compiles.

---

• OderWat (orginal) [2015-02-16T17:33:22+01:00] view original

  It gives you a copy of the seq. Add something before the getOk() line and you will see. You may also use repr() to peek at it.

---

• def (orginal) [2015-02-16T17:39:42+01:00] view original

  Should creates a sequence but is that "x.ok" the same as "result = x.ok" in this case

  Yes, the last expression is automatically the result variable.

  And what do we get, a new sequence, or the old from x object?

  You can't get the same sequence, because that would require x to be var. So a copy has to be made. If you use a var seq[int] return type you will indeed get the same sequence back:

  proc getOk(x: var Test): var seq[int] =
    x.ok
  Run

---

• OderWat (orginal) [2015-02-16T17:40:20+01:00] view original

  Try this:

  type
      Test = object
          ok: seq[int]
  
  proc getOk(x: Test): seq[int] =
      echo "2: ", repr(x.ok)
      result=x.ok
      echo "3: ", repr(result)
  
  var x = Test(ok: @[])
  echo "1: ", repr(x.ok)
  
  x.ok.add(1)
  
  var ok = x.getOk()
  echo "4: ", repr(ok)
  
  ok.add(3)
  
  echo x.ok # @[1]
  
  Run

  gives something like this

  
  1: 0x101ee5050[]
  
  2: 0x101ee6050[1]
  
  3: 0x101ee7050[1]
  
  4: 0x101ee7050[1]
  
  @[1]
  Run

  You can identify where copies are made and where not this way.

  EDIT: Added some numbers for the "rep() representations"

  Second Example:

  type
      Test = object
          ok: ref seq[int]
  
  proc newTest: Test =
      result.ok = new seq[int]
      result.ok[] = @[]
  
  var x = newTest()
  var ok = x.ok
  
  ok[].add(3)
  
  var y = x
  
  y.ok[].add(1)
  
  echo "1: ", x.ok[].repr()
  echo "2: ", y.ok[].repr()
  
  y.ok[].add(2)
  
  proc tryThis(x: Test): ref seq[int] =
      echo "3: ", x.ok[].repr()
      result = x.ok
      echo "4: ", result.repr()
  
  let z = tryThis(x)
  
  z[].add(4)
  
  echo "5: ", z.repr()
  
  echo "6: ", x.ok[].repr()
  Run

  Gives:

  
  1: 0x103983050[3, 1]
  
  2: 0x103983050[3, 1]
  
  3: 0x103983050[3, 1, 2]
  
  4: ref 0x103981050 --> 0x103983050[3, 1, 2]
  
  5: ref 0x103981050 --> 0x103983050[3, 1, 2, 4]
  
  6: 0x103983050[3, 1, 2, 4]
  Run

---

• bozaloshtsh (orginal) [2015-02-16T22:23:51+01:00] view original

  Thanks for the help, I think I've got it now

---