Jump to content

  • Log In with Google      Sign In   
  • Create Account


How does this code work?


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
2 replies to this topic

#1 noatom   Members   -  Reputation: 769

Like
0Likes
Like

Posted 07 April 2013 - 02:38 PM

//: C12:ReferenceCounting.cpp
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
// Reference count, copy-on-write
#include "../require.h"
#include <string>
#include <iostream>
using namespace std;

class Dog {
  string nm;
  int refcount;
  Dog(const string& name) 
    : nm(name), refcount(1) {
    cout << "Creating Dog: " << *this << endl;
  }
  // Prevent assignment:
  Dog& operator=(const Dog& rv);
public:
  // Dogs can only be created on the heap:
  static Dog* make(const string& name) {
    return new Dog(name);
  }
  Dog(const Dog& d) 
    : nm(d.nm + " copy"), refcount(1) {
    cout << "Dog copy-constructor: " 
         << *this << endl;
  }
  ~Dog() { 
    cout << "Deleting Dog: " << *this << endl;
  }
  void attach() { 
    ++refcount;
    cout << "Attached Dog: " << *this << endl;
  }
  void detach() {
    require(refcount != 0);
    cout << "Detaching Dog: " << *this << endl;
    // Destroy object if no one is using it:
    if(--refcount == 0) delete this;
  }
  // Conditionally copy this Dog.
  // Call before modifying the Dog, assign
  // resulting pointer to your Dog*.
  Dog* unalias() {
    cout << "Unaliasing Dog: " << *this << endl;
    // Don't duplicate if not aliased:
    if(refcount == 1) return this;
    --refcount;
    // Use copy-constructor to duplicate:
    return new Dog(*this);
  }
  void rename(const string& newName) {
    nm = newName;
    cout << "Dog renamed to: " << *this << endl;
  }
  friend ostream&
  operator<<(ostream& os, const Dog& d) {
    return os << "[" << d.nm << "], rc = " 
      << d.refcount;
  }
};

class DogHouse {
  Dog* p;
  string houseName;
public:
  DogHouse(Dog* dog, const string& house)
   : p(dog), houseName(house) {
    cout << "Created DogHouse: "<< *this << endl;
  }
  DogHouse(const DogHouse& dh)
    : p(dh.p),
      houseName("copy-constructed " + 
        dh.houseName) {
    p->attach();
    cout << "DogHouse copy-constructor: "
         << *this << endl;
  }
  DogHouse& operator=(const DogHouse& dh) {
    // Check for self-assignment:
    if(&dh != this) {
      houseName = dh.houseName + " assigned";
      // Clean up what you're using first:
      p->detach();
      p = dh.p; // Like copy-constructor
      p->attach();
    }
    cout << "DogHouse operator= : "
         << *this << endl;
    return *this;
  }
  // Decrement refcount, conditionally destroy
  ~DogHouse() {
    cout << "DogHouse destructor: " 
         << *this << endl;
    p->detach(); 
  }
  void renameHouse(const string& newName) {
    houseName = newName;
  }
  void unalias() { p = p->unalias(); }
  // Copy-on-write. Anytime you modify the 
  // contents of the pointer you must 
  // first unalias it:
  void renameDog(const string& newName) {
    unalias();
    p->rename(newName);
  }
  // ... or when you allow someone else access:
  Dog* getDog() {
    unalias();
    return p; 
  }
  friend ostream&
  operator<<(ostream& os, const DogHouse& dh) {
    return os << "[" << dh.houseName 
      << "] contains " << *dh.p;
  }
}; 

int main() {
  DogHouse 
    fidos(Dog::make("Fido"), "FidoHouse"),
    spots(Dog::make("Spot"), "SpotHouse");
  cout << "Entering copy-construction" << endl;
  DogHouse bobs(fidos);
  cout << "After copy-constructing bobs" << endl;
  cout << "fidos:" << fidos << endl;
  cout << "spots:" << spots << endl;
  cout << "bobs:" << bobs << endl;
  cout << "Entering spots = fidos" << endl;
  spots = fidos;
  cout << "After spots = fidos" << endl;
  cout << "spots:" << spots << endl;
  cout << "Entering self-assignment" << endl;
  bobs = bobs;
  cout << "After self-assignment" << endl;
  cout << "bobs:" << bobs << endl;
  // Comment out the following lines:
  cout << "Entering rename(\"Bob\")" << endl;
  bobs.getDog()->rename("Bob");
  cout << "After rename(\"Bob\")" << endl;
} ///:~

 

 

 

Please read the code,and continue only after you understand it,it's pretty hard to explain it by writing.

So,there are 2 classes,doghouse and dog.Multiple doghouses can be attached to a dog,that's the main ideea.

Now,let's focus on this:

 

p->detach();
p = dh.p; // Like copy-constructor
p->attach();

 

 

this line: p = dh.p

creates a dog with a refcount of 1,which is fine but later attach is called and the refcount goes to 2.Why 2? only a doghouse is really attached to it!

 

 

 

 

 

 

 

 

If you understand the code,please explain with details when I assign a doghouse to another(and they're both initialized ofcourse)


Edited by noatom, 07 April 2013 - 02:47 PM.


Sponsor:

#2 Juliean   GDNet+   -  Reputation: 2230

Like
0Likes
Like

Posted 07 April 2013 - 03:12 PM

Here:

 

  // Prevent assignment:
  Dog& operator=(const Dog& rv);

This invalidates the assignement operator, so when you think you are doing "p = dh.p;", as in copying dh.p in p, you are instead doing virtuall nothing.

 

Word of advice, whether you c&p this or wrote it yourself, (ok, so you didn't write it, still:) this code could really need some spacing. Thats horrible to read, try to at least put a spacing between every function, wasn't the problem so obvious, it might have taken a while to find out why...


Edited by Juliean, 07 April 2013 - 03:14 PM.


#3 Adam_42   Crossbones+   -  Reputation: 2361

Like
0Likes
Like

Posted 07 April 2013 - 05:08 PM

this line: p = dh.p

creates a dog with a refcount of 1,which is fine but later attach is called and the refcount goes to 2.Why 2? only a doghouse is really attached to it!

 

That line of code does not create anything. It simply copies a pointer to an existing Dog.

 

It also has nothing to do with the assignment operator.

 

Also note that a Dog with a refcount of 0 will only exist inside the detach() function, just before it gets deleted.

 

The DogHouse assignment operator does something that makes little sense for a real life dog house. It effectively copies the Dog from the other DogHouse so it exists in both DogHouses at the same time.






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS