StringTest.C File Reference

Regression and verification code for the String class. More...

#include <stdio.h>
#include <string.h>
#include "String.h"

Include dependency graph for StringTest.C:

Go to the source code of this file.

Functions
void	checkRefCntVal (String s, size_t shouldBe, const char *prefix)
	checkRefCntVal: pass by value, where reference count gets incremented by one on entry and decremented by one on exit.
void	checkRefCnt (String &s, size_t shouldBe, const char *prefix)
	checkRefCnt: pass by reference.
void	test_constructors ()
	test_constructors
void	test_char_cast ()
	test_char_cast
void	test_assign ()
void	test_plus_equal ()
	test_plus_equal
void	test_plus ()
	test_plus
void	test_relops ()
	test_relops
void	test_arrayop ()
	Array reference [] operator tests.
void	test_insert ()
	test_insert()
void	test_substr_func_valarg (SubString sub, size_t errorNum)
void	test_substring ()
	test_substring
void	test_resize ()
	test_resize
	main ()

---

Detailed Description

Regression and verification code for the String class.

No errors should be printed when this code runs.

You really need to run these regression tests before using this code on your system. This code has been tested on a variety of platforms. Although C++ compilers are getting more standard conformant, this the String class uses C++ features which historically been supported differently by different compilers.

Note that the existence of these regression tests does not change that statement this code is provided without waranty. You use this code at your own risk.

I also recommend verifying this code using Purify or a similar memory usage verification tool. This level of pain and difficulty should not be necessary, but hey, its C++.

In an earlier version of the String class the SubString class was included in the same .h file, with some function implementations in String.C.

This version separates the two classes. A set of regression tests (SubStrTest.C) was written for the SubString class. However, for historical reasons, this file also include some tests for SubString, which overlap with the tests in SubStrTest.C.

Compiling this code:

This code is written to compile on Microsoft Visual C++ 6.0 and higher. It will also compile on GNU C++ and Sun's 6.0 and later C++ compilers. To compile under Microsoft VC++:

      cl -Zi -TP -GX SubString.C String.C StringTest.C -o StringTest

The -GX flag is needed to support exceptions, which are used rather than the assert() functions in the earlier versions.

Copyright and Use

You may use this source code without limitation and without fee as long as you include:

     This software was written and is copyrighted by Ian Kaplan, Bear
     Products International, www.bearcave.com, 2001.

This software is provided "as is", without any warrenty or claim as to its usefulness. Anyone who uses this source code uses it at their own risk. Nor is any support provided by Ian Kaplan and Bear Products International.

Please send any bug fixes or suggested source changes to:

     iank@bearcave.com

Definition in file StringTest.C.

---

Function Documentation

void checkRefCnt (  String &  s, size_t  shouldBe, const char *  prefix )

checkRefCnt: pass by reference. The reference count in the String object is unchanged, since the object is passed by reference. Definition at line 87 of file StringTest.C. References String::getRefCnt(). Referenced by test_constructors(). { if (s.getRefCnt() != shouldBe) printf("%s refCnt = %d (should be %d)\n", prefix, s.getRefCnt(), shouldBe ); } // checkRefCnt

void checkRefCntVal (  String  s, size_t  shouldBe, const char *  prefix )

checkRefCntVal: pass by value, where reference count gets incremented by one on entry and decremented by one on exit. Definition at line 74 of file StringTest.C. References String::getRefCnt(). Referenced by test_constructors(). { if (s.getRefCnt() != shouldBe) printf("%s refCnt = %d (should be %d)\n", prefix, s.getRefCnt(), shouldBe ); } // checkRefCntVal

main (   )

Definition at line 1108 of file StringTest.C. References test_arrayop(), test_assign(), test_char_cast(), test_constructors(), test_insert(), test_plus(), test_plus_equal(), test_relops(), test_resize(), and test_substring(). { test_constructors(); test_char_cast(); test_assign(); test_plus_equal(); test_plus(); test_relops(); test_arrayop(); test_insert(); test_substring(); test_resize(); return 0; }

void test_arrayop (   )

Array reference [] operator tests. There are two versions: left hand size and right hand size array operators. The right hand side version returns a value, the left hand size operator returns an address (to which a value can be assigned). Definition at line 718 of file StringTest.C. References String::getRefCnt(). Referenced by main(). { const char *jabbar = "He took his vorpal sword in hand"; const char *newJabbar1 = "He took her vorpal sword in hand"; // index 9 -----------------^ const char *newJabbar2 = "He took her vorpal ruler in hand"; // index 19 ----------------------------^ const char *newWord = "ruler"; const size_t len = strlen( jabbar ); String jabbarString( jabbar ); String jabbarRefStr = jabbarString; // // Make sure that integer operators on the RHS work properly // if (jabbarString[3] != 't') { printf("0. string index failed\n"); } // make sure than in index operation does not cause a copy if (jabbarRefStr.getRefCnt() != 2) { printf("0.5. string index seems to have caused a copy\n"); } for (size_t i = 0; i < len; i++) { char lhsCh = jabbarString[i]; char rhsCh = jabbar[i]; if (lhsCh != rhsCh) { printf("1. mismatch on rhs String index\n"); } } // references are jabbarString, jabbarRefStr and now, "a" String a = jabbarString; if (a.getRefCnt() != 3) printf("2. reference count is wrong\n"); a[9] = 'e'; a[10] = 'r'; // The string has been changed, so a "copy on write" should // have taken place. Now there is a single copy, with the // change. if (a.getRefCnt() != 1) printf("3. 'a' reference count is wrong\n"); if (jabbarString.getRefCnt() != 2) printf("4. jabbarString reference count is wrong\n"); const char *tmp = a; if (strcmp(tmp, newJabbar1) != 0) { printf("5. strings don't match: a = %s, should be %s\n", tmp, newJabbar1 ); } // make sure that the original string is unchanged tmp = jabbarString; if (strcmp(tmp, jabbar) != 0) { printf("6. strings don't match: a = %s, should be %s\n", tmp, jabbar ); } } // test_arrayop

void test_assign (   )

Definition at line 179 of file StringTest.C. References String::getRefCnt(). Referenced by main(). { printf("Test assignment\n"); const char *testStr = "my girl is the best"; String a = "abcd"; const char *tmp = a; if (strcmp(tmp, "abcd") != 0) printf("1. Assignment in declaration failed\n"); const char *init_b = "this is not it"; String b(init_b); String original_b; original_b = b; b = testStr; if (b.getRefCnt() != 1) printf("2. reference count for b is wrong\n"); tmp = b; if (strcmp(tmp, testStr) != 0) printf("3. String has incorrect contents\n"); if (original_b.getRefCnt() != 1) printf("4. reference count for original_b is wrong\n"); if (original_b != init_b) printf("5. modification of b improperly changed original_b\n"); String c( testStr ); c = b; if (b.getRefCnt() != 2) printf("6. reference count is wrong\n"); const char *nullPtr = 0; String d; if (d != "") { printf("7. comparision to a null string failed\n"); } d = nullPtr; if (d != "") { printf("8. assignment of a null C-string failed\n"); } d = testStr; tmp = d; if (strcmp(tmp, testStr) != 0) printf("9. String has incorrect contents\n"); String e = String( testStr ); tmp = e; if (strcmp(tmp, testStr) != 0) printf("10. String has incorrect contents\n"); if (e.getRefCnt() != 1) printf("11. refCnt is wrong: refCnt = %d, should be 1\n", e.getRefCnt() ); const char *constCStr = "1234567890"; const size_t len = sizeof(constCStr) / sizeof(char); String foo = constCStr; String bar = foo; if (foo.getRefCnt() != 2) { printf("12. refcnt is wrong: refCnt = %d, should be 2\n", foo.getRefCnt() ); } // This makes sure that the [] operator is implemented properly // and does not cause a "copy-on-write" on a read operation. bool contentOK = true; for (size_t i = 0; i < len; i++) { if (constCStr[i] != foo[i]) { contentOK = false; break; } } if (!contentOK) { printf("13: content is wrong\n"); } // make sure refCnt is still OK if (bar.getRefCnt() != 2) { printf("14. refcnt is wrong: refCnt = %d, should be 2\n", bar.getRefCnt() ); } const char *testStr2 = "null is a lonely number"; String r = testStr2; String r2 = r; r = '\0'; if (r != "") { printf("15. assignment of null character did not result in empty str\n"); } if (r2 != testStr2) { printf("16. null character assignment changed a shared string\n"); } if (r2.getRefCnt() != 1) { printf("17. reference count is wrong\n"); } const char *testStr3 = "\"Writing tests is hard!\" said Barbie"; String s = testStr3; String s2 = s; s = ""; if (s != "") { printf("18. assignment of empty string did not result in empty str\n"); } if (s2 != testStr3) { printf("19. empty string assignment changed a shared string\n"); } if (s2.getRefCnt() != 1) { printf("17. reference count is wrong\n"); } // Test chained assignment const char *testStr4 = "working on the chain gang"; String w, x, y; w = x = y = testStr4; if (w != testStr4 || x != testStr4 || y != testStr4) { printf("18. chained assignment failed\n"); } if (y.getRefCnt() != 3) { printf("19. reference count in chained assignment is wrong\n"); } String z = "still working on the gang"; w = x = y = z; if (w != x && x != y && y != z) { printf("20. chained assignment failed\n"); } if (y.getRefCnt() != 4) { printf("21. reference count in chained assignment is wrong\n"); } } // test_assign

void test_char_cast (   )

test_char_cast Definition at line 151 of file StringTest.C. Referenced by main(). { printf("Test character cast\n"); const char *testStr = "the quick brown fox"; String a( testStr ); const char *tmp = a; if (tmp == 0) printf("1. error: result of cast is null\n"); else if (strcmp(testStr, tmp) != 0) printf("2. error: strings are not equal\n"); } // test_char_cast

void test_constructors (   )

test_constructors Definition at line 98 of file StringTest.C. References checkRefCnt(), checkRefCntVal(), String::getRefCnt(), and String::strlen(). Referenced by main(). { String a( "abcd" ); String b( a ); printf("Test String constructors\n"); if (b.getRefCnt() != 2) printf("1. Reference count is wrong: refCnt = %d (should be 2)\n", b.getRefCnt() ); String c = a; if (b.getRefCnt() != 3) printf("2. Reference count is wrong: refCnt = %d (should be 3)\n", b.getRefCnt() ); if (a.getRefCnt() != 3) printf("3. Reference count is wrong: refCnt = %d (should be 3)\n", b.getRefCnt() ); checkRefCntVal( a, 4, "4. "); if (a.getRefCnt() != 3) printf("4. Reference count is wrong: refCnt = %d (should be 3)\n", b.getRefCnt() ); checkRefCnt( a, 3, "5. "); String d( 'd' ); // test for construction with an empty string String e; String f( e ); checkRefCnt( f, 2, "6. "); checkRefCntVal( f, 3, "7. "); // test of a pointer containing null const char *nullPtr = 0; String g( nullPtr ); // test of a null address String h( (const char *)0 ); String i( '\0' ); if (i.strlen() != 0) { printf("8. Adding a null character should not increase length\n"); } } // test_constructors

void test_insert (   )

test_insert() In an earlier version of the String object used an explicit insert function to insert a string into another string. This is very much like assigning to a SubString. In the case of an insert the length of the section being replaced is 0. This code attempts to not only make sure that insert works, but also that insert works for various corner cases (e.g., insert of an empty string or a null C string). Definition at line 800 of file StringTest.C. References String::getRefCnt(). Referenced by main(). { printf("Test string insert\n"); const char *origA = "abcdefgh"; const char *rslt1 = "abcd1234efgh"; String a(origA); String b("1234"); String c = a; // test insert of a String into a String // reference count should be 2, since a and c have the // same shared data if (a.getRefCnt() != 2) printf("1. reference count is wrong\n"); a(4,0) = b; // make sure a is "abcd1234efgh" if (a != rslt1) { printf("2. insert failed. a = [%s], should be [%s]\n", (const char *)a, rslt1 ); } // a should be unique if (a.getRefCnt() != 1) printf("3. reference count in a is wrong\n"); // c should be unique if (c.getRefCnt() != 1) printf("4. reference count in c is wrong\n"); // The contents of c should be unchanged if (c != origA) printf("5. contents of c is wrong\n"); // test insert of C-string into a String String d = c; d(4,0) = "1234"; // make sure d is "abcd1234efgh" if (d != rslt1) { printf("6. insert failed. d = [%s], should be [%s]\n", (const char *)d, rslt1 ); } String c_prime = c; // reference count is 2 // test insert of a zero length C string into a String // (remember, c is still "abcdefgh") c(4, 0) = ""; // make sure c is "abcdefgh" (e.g., nothing happened) if (c != origA) { printf("7. insert failed. c = [%s], should be [%s]\n", (const char *)c, origA ); } // Insert a null string into a String object (should do nothing) c_prime(4, 0) = (const char *)0; // make sure that reference count is still 2 if (c.getRefCnt() != 2) printf("8. c.getRefCnt() = %d, should be 2\n", c.getRefCnt()); if (c_prime.getRefCnt() != 2) printf("9. c_prime.getRefCnt() = %d, should be 2\n", c_prime.getRefCnt()); if (c_prime != origA) { printf("10. insert failed. c_prime = [%s], should be [%s]\n", (const char *)c_prime, origA ); } // test insert of an empty String into "c", an non-empty string. String emptyString; // try insert at index 0 c(0,0) = emptyString; // make sure c is "abcdefgh" (e.g., nothing happened) if (c != origA) { printf("11. insert failed. c = [%s], should be [%s]\n", (const char *)c, origA ); } // try insert at index 4 c(4,0) = emptyString; // make sure c is "abcdefgh" (e.g., nothing happened) if (c != origA) { printf("12. insert failed. c = [%s], should be [%s]\n", (const char *)c, origA ); } } // test_insert

void test_plus (   )

test_plus Definition at line 435 of file StringTest.C. References String::getRefCnt(). Referenced by main(). { printf("Test + operator\n"); const char *firstHalf = "abcd"; const char *secondHalf = " efgh"; const char *concatStr = "abcd efgh"; // // Test String + String // String t1( firstHalf ); String t2( secondHalf ); String a = t1 + t2; if (a.getRefCnt() != 1) { printf("1. refCnt is wrong: refCnt = %d, should be 1\n", a.getRefCnt() ); } if (strcmp((const char *)a, concatStr) != 0) printf("2. String contents are not correct: a = %s (should be [%s])\n", (const char *)a, concatStr ); // // Test String + const char * // String b = t1 + secondHalf; if (b.getRefCnt() != 1) { printf("3. refCnt is wrong: refCnt = %d, should be 1\n", b.getRefCnt() ); } const char *tmp = b; if (strcmp(tmp, concatStr) != 0) printf("4. String contents are not correct: b = %s (should be [%s])\n", tmp, concatStr ); // // test the global String addition operator const char * + String // String c = firstHalf + t2; tmp = c; if (strcmp(tmp, concatStr) != 0) printf("5. String contents are not correct: c = %s (should be [%s])\n", tmp, concatStr ); // // Make sure that the operands of the addition are not altered by // the addition // String first( firstHalf ); String second( secondHalf ); String d = first + second; tmp = first; if (strcmp(tmp, firstHalf) != 0) printf("6. first has been altered: first = %s (should be [%s])\n", tmp, firstHalf ); tmp = second; if (strcmp(tmp, secondHalf) != 0) printf("7. second has been altered: second = %s (should be [%s])\n", tmp, secondHalf ); tmp = d; if (strcmp(tmp, concatStr) != 0) printf("8. String contents are not correct: d = %s (should be [%s])\n", tmp, concatStr ); // // Test character concatenation. Here the character operands // are converted to String objects. // String e("12345"); String f; String g; f = e + '6' + '7' + '8' + '9'; g = 'a' + f; if (e != "12345") printf("9. String e changed\n"); if (f != "123456789") { const char *tmp = f; printf("10. String f is %s, it should be \"123456789\"\n", tmp); } if (g != "a123456789") printf("11. g is incorrect\n"); // Test addition with chained assignment and string operands String w( "foo" ); String x( "bar" ); String y; String z = y = w + x; if (y != "foobar") { const char *tmp = y; printf("12. String y is %s, it should be \"foobar\"\n", tmp ); } if (z != "foobar") { const char *tmp = z; printf("13. String z is %s, it should be \"foobar\"\n", tmp ); } // The reference counts for w and x should both be 1 if (w.getRefCnt() != 1) { printf("14. w.getRefCnt() = %d, it should be 1\n", w.getRefCnt() ); } if (x.getRefCnt() != 1) { printf("15. x.getRefCnt() = %d, it should be 1\n", x.getRefCnt() ); } if (y.getRefCnt() != 2) { printf("16. y.getRefCnt() = %d, it should be 2\n", y.getRefCnt() ); } if (z.getRefCnt() != 2) { printf("17. z.getRefCnt() = %d, it should be 2\n", z.getRefCnt() ); } } // test_plus

void test_plus_equal (   )

test_plus_equal Definition at line 333 of file StringTest.C. References String::getRefCnt(). Referenced by main(). { const char *firstHalf = "abcd"; const char *secondHalf = " efgh"; const char *concatStr = "abcd efgh"; printf("Test += operator\n"); String a( firstHalf ); a += secondHalf; const char *tmp = a; if (strcmp(tmp, concatStr) != 0) printf("1. Strings did not match: str = %s (should be [%s]\n", tmp, concatStr ); String b; b += firstHalf; tmp = b; if (strcmp(tmp, firstHalf) != 0) printf("2. Strings did not match: str = %s (should be [%s]\n", tmp, firstHalf ); String d, c; c += d; if (c.getRefCnt() != 1) printf("3. refCnt should (still) be 1\n"); if (d != "" || c != "") { printf("4. Strings c and d should be the empty string, but are not\n"); } c += secondHalf; tmp = c; if (strcmp(tmp, secondHalf) != 0) printf("5. Strings did not match: str = %s (should be [%s]\n", tmp, secondHalf ); String e("1234"); for (size_t i = 5; i < 10; i++) { e += (char)(i + (char)'0'); } if (e != "123456789") { tmp = e; printf("6. Character concat failed: d = %s, should be 123456789\n", tmp ); } const char *testStr1 = "metal jacket"; String empty; String full(testStr1); empty += full; if (empty.getRefCnt() != 1) { printf("7. empty.getRefCnt() = %d, should be 1\n", empty.getRefCnt() ); } if (empty != testStr1) { printf("8. empty string += String failed\n"); } const char *testStr2 = "foo"; String empty2; const char *str = testStr2; empty2 += str; if (empty2.getRefCnt() != 1) { printf("9. empty2.getRefCnt() = %d, should be 1\n", empty2.getRefCnt() ); } if (empty2 != testStr2) { printf("10. empty string += C-string failed\n"); } // test chained assignment const char *testStr3 = "twas brillig"; String s1 = "twas "; String s2 = "brillig"; String s3 = s1 += s2; if (s3 != s1 && s1 != testStr3) { printf("11. chained assignment with += failed\n"); } if (s3.getRefCnt() != 2 && s1.getRefCnt() != 2 && s2.getRefCnt() != 1) { printf("12. reference count for chained assignment with += failed\n"); } } // test_plus_equal

void test_relops (   )

test_relops Test relational operators Definition at line 567 of file StringTest.C. Referenced by main(). { printf("Test relational operators\n"); const char *less = "abcd"; const char *greater = "wxyz"; const char *equal = "abcd"; String lessString( less ); String greaterString( greater ); String equalString( equal ); // note that equalString == lessString == less String same; same = less; // // == // // String String // // Check the case where both strings contain no data // (and so are equal). String x, y; // two empty strings if (x != y) printf("0. empty strings are not equal\n"); if (x != "") { printf("0.5: String not equal to empty C string\n"); } if (! (lessString == equalString)) printf("1. String == String failed\n"); // String const char * if (! (lessString == equal)) printf("2. String == const char * failed\n"); // const char * String if (! (equal == lessString)) printf("3. const char * == String failed\n"); if (! (same == less)) printf("String == String failed for String objs w/same shared data\n"); // // != // // String String if (! (lessString != greaterString)) printf("4. String != String failed\n"); // String const char * if (! (lessString != greater)) printf("5. String != const char * failed\n"); // const char * String if (! (less != greaterString)) printf("6. const char * != String failed\n"); // // >= // // String String if (! (greaterString >= lessString)) printf("7. String >= String failed for >\n"); if (! (lessString >= equalString)) printf("8. String >= String failed for ==\n"); // String const char * if (! (greaterString >= less)) printf("9. String >= const char * failed for >\n"); if (! (lessString >= equal)) printf("10. String >= const char * failed ==\n"); // const char * String if (! (greater >= lessString)) printf("11. const char * >= String failed for >\n"); if (! (equal >= lessString)) printf("12. const char * >= String failed for ==\n"); // // <= // // String String if (! (lessString <= greaterString)) printf("13. String <= String failed for <\n"); if (! (lessString <= equalString)) printf("14. String <= String failed for ==\n"); // String const char * if (! (lessString <= greater)) printf("15. String <= const char * failed for <\n"); if (! (lessString <= equal)) printf("16. String <= const char * failed for ==\n"); // const char * String if (! (less <= greaterString)) printf("17. const char * <= String failed for <\n"); if (! (equal <= lessString)) printf("18. const char * <= String failed for ==\n"); // // > // // String String if (! (greaterString > lessString)) printf("19. String > String failed\n"); // String const char * if (! (greaterString > less)) printf("20. String > const char * failed\n"); // const char * String if (! (greater > lessString)) printf("21. const char * > String failed\n"); // // < // // String String if (! (lessString < greaterString)) printf("22. String < String failed\n"); // String const char * if (! (lessString < greater)) printf("23. String < const char * failed\n"); // const char * String if (! (less < greaterString)) printf("24. const char * < String failed\n"); } // test_relops

void test_resize (   )

test_resize Test the String object resize function. Definition at line 1051 of file StringTest.C. References String::resize(), and String::strlen(). Referenced by main(). { const char *init_a = "01234567890123456789"; String a( init_a ); String b = a; const char *tmp; printf("Test resize\n"); b.resize(10); // set size of String b to 10 if (b.strlen() != 10) printf("1. b.strlen() = %d, should be 10\n", b.strlen() ); if (b != "0123456789") { tmp = b; printf("2. b = %s, should be \"0123456789\"\n", tmp ); } if (a != init_a) printf("3. a was improperly modified by resizing b\n"); if (a.strlen() != 20) printf("4. a.strlen() = %d, should be 20\n", a.strlen() ); b.resize(20); if (b != "0123456789 ") { tmp = b; printf("5. b = %s, should be \"0123456789 \"\n", tmp ); } if (b.strlen() != 20) printf("6. b.strlen() = %d, should be 20\n", b.strlen() ); if (a != init_a) printf("8. resizing b modified a\n"); b.resize( 0 ); String empty; if (b != empty) printf("9. b is not the same as the empty string\n"); if (a != init_a) printf("10. resizing b modified a\n"); if (b.strlen() != 0) printf("11. b.strlen() = %d, should be 0\n", b.strlen() ); if (b != "") { printf("12. b should be the same as the empty string\n"); } } // test_resize

void test_substr_func_valarg (  SubString  sub, size_t  errorNum )

Definition at line 893 of file StringTest.C. References SubString::getRefCnt(). Referenced by test_substring(). { if (sub.getRefCnt() != 1) { printf("%d. sub.getRefCnt() = %d, should be 1\n", errorNum, sub.getRefCnt() ); } if (sub != "de") { printf("%d. sub.string = %s, should be \"de\"\n", errorNum + 1, (const char *)((String)sub) ); } } // test_substr_func_valarg

void test_substring (   )

test_substring Test operations on SubStrings via the String() operator. These test overlap the SubString class tests. They are here for historical reasons. Definition at line 917 of file StringTest.C. References String::getRefCnt(), String::strlen(), and test_substr_func_valarg(). Referenced by main(). { printf("Test sub-string operations\n"); const char *init_a = "abcdefgh"; String a(init_a); if (a(3, 4).getRefCnt() != 1) { printf("1. reference count is wrong\n"); } test_substr_func_valarg( a(3, 2 ), 2 ); String b = a; // b is "abcdefgh // insert "1234" at position 3 b(3, 4) = "1234"; if (a != init_a) { printf("3. \"a\" was altered when b(3, 4) was changed\n"); } if (b != "abc1234h") { printf("4. b = %s, should be \"abc1234h\"\n", (const char *)b); } if (a.getRefCnt() != 1 || b.getRefCnt() != 1) { printf("5. a.getRefCnt() = %d, b.getRefCnt() = %d (both should be 1)\n", a.getRefCnt(), b.getRefCnt() ); } String c; c = b(3, 4); if (c != "1234") { printf("6. c = %s, should be \"1234\"\n", (const char *)c); } if (c.strlen() != 4) { printf("7. c.strlen() = %d, should be 4\n", c.strlen()); } String d("1234abcdefgh"); String e; e = d(4, 8) + d(0, 4); // e = d << 4 if (e != "abcdefgh1234") { printf("8. e = %s, should be \"abcdefgh1234\"\n", (const char *)e ); } if (d != "1234abcdefgh") { printf("9. d was changed by the SubString operations\n"); } if (d.getRefCnt() != 1) { printf("10. d.getRefCnt() = %d, it should be 1\n", d.getRefCnt()); } // // According to 10.4.10 Temporary Objects in "The C++ Programming // Language", Third Edition, by Stroustrup: // // Unless bound to a reference or used to initialize a named // object, a temporary object is destroyed at the end of teh full // expression in which it was created. A full expression is an // expression that is not a subexpression of some other // expression. // // Stroustrup goes on to provide an example using the Standard // Template Library (STL) "string" class. Here the c_str() // function returns a "C" language string. // // const char* cs = (s1 + s2).c_str(). // // A temporary object of class string is created to hold s1+s2. // Next, a pointer to a C-style string is extracted from the // object. Then - at the end of the expression - the temporary // object is deleted. Now, where was the C-style string // allocated? Probably as part of the temporary object holding // s1+s2, and that storage is not guaranteed to exist after that // temporary is destroyted. Consequently, cs points to // deallocated storage. // // In the case of the String container, the expression // // e = d(4, 8) + d(0, 4); // // creates a String object temporary, which is assigned to "e" // // <allocate String temporary object CompilerTemp> // <CompilerTemp> = d(4, 8) + d(0, 4); // e = <CompilerTemp> Note: at this point getRefCnt = 2 // <destructor called for CompilerTemp> Note: refCnt decremented // next statement // // By the time we reach "next statement" the destructor is called // and the reference counter for "e" is 1, which is what we would // expect. // // If this example does not convience you that C++ is a complicated // language, nothing will. // if (e.getRefCnt() != 1) { printf("11. e.getRefCnt() = %d, it should be 1\n", e.getRefCnt()); } // // Note that the SubString object created by the () operator is // a new object and so has a reference count of 1, although the // String associated with it has a reference count of two. String z = "lost Z-man"; String y = z; // refCnt is now 2 if (z(5, 5).getRefCnt() != 1) { printf("12. z(8, 4).getRefCnt() = %d, should be 1\n", z(8, 4).getRefCnt() ); } String f("chopsock"); f(4, 4) = f(0, 4); if (f != "chopchop") { printf("13. f = %s, should be \"chopchop\"\n", (const char *)f ); } } // test_substring

---