X-Git-Url: https://mattmccutchen.net/bigint/bigint.git/blobdiff_plain/2f145f11d5d5ab979a7f5a5e3b26fc9882dc345c..4efbb07622a0aa83db4fe05ca8c17aca406ed928:/NumberlikeArray.hh

diff --git a/NumberlikeArray.hh b/NumberlikeArray.hh
index 4fe2a42..3b018a4 100644
--- a/NumberlikeArray.hh
+++ b/NumberlikeArray.hh
@@ -20,8 +20,8 @@
 #endif
 
 /*
-* A NumberlikeArray<Block> object holds a dynamically
-* allocated array of Blocks.  It provides certain basic
+* A NumberlikeArray<Blk> object holds a dynamically
+* allocated array of Blk.  It provides certain basic
 * memory management features needed by both BigUnsigned
 * and BigUnsignedInABase, which are both derived from it.
 *
@@ -37,56 +37,17 @@
 *     NumberlikeArray< whatever >::getLength;
 */
 
-/*debug*/
-#include <iostream>
-
 template <class Blk>
 class NumberlikeArray {
 	public:
 	
 	typedef unsigned int Index; // Type for the index of a block in the array
+	static const unsigned int N; // The number of bits in a block, defined below.
 	
 	// FIELDS
 	Index cap; // The current allocated capacity of this NumberlikeArray (in blocks)
 	Index len; // The actual length of the value stored in this NumberlikeArray (in blocks)
-	Blk *blk2; // Dynamically allocated array of the blocks
-	
-	static Blk x; // trash that [] can return for out-of-range requests
-	
-	void dump() const {
-		std::cout << "Dumping NumberlikeArray @ " << (void *)(this) << '\n';
-		std::cout << "Length " << (len) << ", capacity " << (cap) << '\n';
-		for (unsigned int i = 0; i < len; i++) {
-			std::cout << "Block " << i << ":" << blk2[i] << '\n';
-		}
-	}
-	
-	struct BoundsCheckingBlk {
-		const NumberlikeArray *na;
-		BoundsCheckingBlk(NumberlikeArray *na) {
-			this->na = na;
-		}
-		Blk & operator [](Index index) const {
-			if (index >= na->len) {
-				std::cout << "== Out-of-bounds access to block " << index << ".  Affected NumberlikeArray: ==\n";
-				na->dump();
-				std::cout << "== End of dump. ==" << std::endl;
-				return x;
-			} else
-				return na->blk2[index];
-		} // dangerous because it allows ``always writable'', but OK for now
-		/*const Blk & operator [](Index index) const {
-			if (index >= na->len)
-				std::cout << "OUT OF BOUNDS!  Length " << (na->len) << ", accessed " << index << std::endl;
-			else
-				return na->blk[index];
-		}*/
-		/*operator Blk * () {
-			return na->blk2;
-		}*/
-	};
-	
-	BoundsCheckingBlk blk;
+	Blk *blk; // Dynamically allocated array of the blocks
 	
 	/*
 	* Change made on 2005.01.06:
@@ -103,8 +64,8 @@ class NumberlikeArray {
 	*/
 	
 	// MANAGEMENT
-	NumberlikeArray(Index c) : cap(c), len(0), blk(this) { // Creates a NumberlikeArray with a capacity
-		blk2 = (cap > 0) ? (new Blk[cap]) : NULL;
+	NumberlikeArray(Index c) : cap(c), len(0) { // Creates a NumberlikeArray with a capacity
+		blk = (cap > 0) ? (new Blk[cap]) : NULL;
 	}
 	void allocate(Index c); // Ensures the array has at least the indicated capacity, maybe discarding contents
 	void allocateAndCopy(Index c); // Ensures the array has at least the indicated capacity, preserving its contents
@@ -127,14 +88,14 @@ class NumberlikeArray {
 	* created a real `new'-allocated zero-length array.  This array would then be lost,
 	* causing a small but annoying memory leak.
 	*/
-	NumberlikeArray() : cap(0), len(0), blk(this) {
-		blk2 = NULL;
+	NumberlikeArray() : cap(0), len(0) {
+		blk = NULL;
 	}
 	NumberlikeArray(const NumberlikeArray<Blk> &x); // Copy constructor
 	void operator=(const NumberlikeArray<Blk> &x); // Assignment operator
 	NumberlikeArray(const Blk *b, Index l); // Constructor from an array of blocks
 	~NumberlikeArray() { // Destructor
-		delete [] blk2; // Does nothing and causes no error if `blk' is null.
+		delete [] blk; // Does nothing and causes no error if `blk' is null.
 	}
 	
 	// PICKING APART
@@ -169,7 +130,7 @@ class NumberlikeArray {
 */
 
 template <class Blk>
-Blk NumberlikeArray<Blk>::x = 0;
+const unsigned int NumberlikeArray<Blk>::N = 8 * sizeof(Blk);
 
 // MANAGEMENT
 
@@ -180,10 +141,10 @@ void NumberlikeArray<Blk>::allocate(Index c) {
 	// If the requested capacity is more than the current capacity...
 	if (c > cap) {
 		// Delete the old number array
-		delete [] blk2;
+		delete [] blk;
 		// Allocate the new array
 		cap = c;
-		blk2 = new Blk[cap];
+		blk = new Blk[cap];
 	}
 }
 
@@ -193,10 +154,10 @@ template <class Blk>
 void NumberlikeArray<Blk>::allocateAndCopy(Index c) {
 	// If the requested capacity is more than the current capacity...
 	if (c > cap) {
-		Blk *oldBlk = blk2;
+		Blk *oldBlk = blk;
 		// Allocate the new number array
 		cap = c;
-		blk2 = new Blk[cap];
+		blk = new Blk[cap];
 		// Copy number blocks
 		Index i;
 		for (i = 0; i < len; i++)
@@ -208,10 +169,10 @@ void NumberlikeArray<Blk>::allocateAndCopy(Index c) {
 
 // Copy constructor
 template <class Blk>
-NumberlikeArray<Blk>::NumberlikeArray(const NumberlikeArray<Blk> &x) : len(x.len), blk(this) {
+NumberlikeArray<Blk>::NumberlikeArray(const NumberlikeArray<Blk> &x) : len(x.len) {
 	// Create array
 	cap = len;
-	blk2 = new Blk[cap];
+	blk = new Blk[cap];
 	// Copy blocks
 	Index i;
 	for (i = 0; i < len; i++)
@@ -236,9 +197,9 @@ void NumberlikeArray<Blk>::operator=(const NumberlikeArray<Blk> &x) {
 
 // Constructor from an array of blocks
 template <class Blk>
-NumberlikeArray<Blk>::NumberlikeArray(const Blk *b, Index l) : cap(l), len(l), blk(this) {
+NumberlikeArray<Blk>::NumberlikeArray(const Blk *b, Index l) : cap(l), len(l) {
 	// Create array
-	blk2 = new Blk[cap];
+	blk = new Blk[cap];
 	// Copy blocks
 	Index i;
 	for (i = 0; i < len; i++)