Here, the constructors allocate the memory and initialize it, the operator= copies it, and the destructor frees the memory...

Odnośniki

Smutek to uczucie, jak gdyby się tonęło, jak gdyby grzebano cię w ziemi.
Search ROM [F0h] When a system is initially brought up, the bus master might not know the number of devices on the 1-Wire bus or their 64-bit ROM codes...
arithmetic operators accuracy of calculations 17-21 overloading 22-29 ActiveX using 17-26 entries for MATLAB 1-6 Array Editor...
You can create delegates for each operation and add them to an ordered collection, such as an array, in the order you'd like them to execute...
The majority of people who work in the pharmaceutical industry subscribe to high standards of integrity and do everything in their power to stay within the constraints of...
initialization activities such as adding Handlers, Filters and Formatters to loggers...
We arrive, then, at a definition of the syllable as a minimal pulse of initiatory activity bounded by a momentary retardation of the initiator, either self-imposed, or, more...
and constructors, 251; behavior of polymorphic 101; ternary, 104; unary, 96, 101 methods inside constructors, 256 operator overloading: in C++,...
Operator /;Operatory arytmetyczne;Priorytet operatorów w języku Visual Basic;Podział operatorów ze względu na funkcjonalność...
(Coleman, 1976)...
appuyer

Smutek to uczucie, jak gdyby się tonęło, jak gdyby grzebano cię w ziemi.

However, if you’re dealing with a lot of memory or a high
overhead to initialize that memory, you may want to avoid this copying. A very common
approach to this problem is called reference counting. You make the block of memory smart, so it knows how many objects are pointing to it. Then copy-construction or assignment means
attaching another pointer to an existing block of memory and incrementing the reference
count. Destruction means reducing the reference count and destroying the object if the
reference count goes to zero.
But what if you want to write to the block of memory? More than one object may be using
this block, so you’d be modifying someone else’s block as well as yours, which doesn’t seem
very neighborly. To solve this problem, an additional technique called copy-on-write is often used. Before writing to a block of memory, you make sure no one else is using it. If the
reference count is greater than one, you must make yourself a personal copy of that block
before writing it, so you don’t disturb someone else’s turf. Here’s a simple example of
reference counting and copy-on-write:
//: C12:Refcount.cpp
// Reference count, copy-on-write
Chapter 10: Operator Overloading
369
#include "../require.h"
#include <cstring>
using namespace std;
class Counted {
class MemBlock {
enum { size = 100 };
char c[size];
int refcount;
public:
MemBlock() {
memset(c, 1, size);
refcount = 1;
}
MemBlock(const MemBlock& rv) {
memcpy(c, rv.c, size);
refcount = 1;
}
void attach() { ++refcount; }
void detach() {
require(refcount != 0);
// Destroy object if no one is using it:
if(--refcount == 0) delete this;
}
int count() const { return refcount; }
void set(char x) { memset(c, x, size); }
// Conditionally copy this MemBlock.
// Call before modifying the block; assign
// resulting pointer to your block;
MemBlock* unalias() {
// Don't duplicate if not aliased:
if(refcount == 1) return this;
--refcount;
// Use copy-constructor to duplicate:
return new MemBlock(*this);
}
}* block;
public:
Counted() {
block = new MemBlock; // Sneak preview
}
Counted(const Counted& rv) {
block = rv.block; // Pointer assignment
Chapter 10: Operator Overloading
370
block->attach();
}
void unalias() { block = block->unalias(); }
Counted& operator=(const Counted& rv) {
// Check for self-assignment:
if(&rv == this) return *this;
// Clean up what you're using first:
block->detach();
block = rv.block; // Like copy-constructor
block->attach();
return *this;
}
// Decrement refcount, conditionally destroy
~Counted() { block->detach(); }
// Copy-on-write:
void write(char value) {
// Do this before any write operation:
unalias();
// It's safe to write now.
block->set(value);
}
};
int main() {
Counted A, B;
Counted C(A);
B = A;
C = C;
C.write('x');
} ///:~
The nested class MemBlock is the block of memory pointed to. (Notice the pointer block defined at the end of the nested class.) It contains a reference count and functions to control and read the reference count. There’s a copy-constructor so you can make a new MemBlock
from an existing one.
The attach( ) function increments the reference count of a MemBlock to indicate there’s another object using it. detach( ) decrements the reference count. If the reference count goes to zero, then no one is using it anymore, so the member function destroys its own object by
saying delete this.
You can modify the memory with the set( ) function, but before you make any modifications, you should ensure that you aren’t walking on a MemBlock that some other object is using.
You do this by calling Counted::unalias( ), which in turn calls MemBlock::unalias( ). The Chapter 10: Operator Overloading
371
latter function will return the block pointer if the reference count is one (meaning no one else is pointing to that block), but will duplicate the block if the reference count is more than one.