异常安全的赋值运算符重载函数 C++ String实现
来源:互联网 发布:app编程入门 编辑:程序博客网 时间:2024/05/01 21:57
异常安全的赋值运算符重载函数
题目:类CMyString的声明如下:
class CMyString
{
public:
CMyString(char* pData = NULL);
CMyString(const CMyString& str);
~CMyString(void);
CMyString& operator = (const CMyString& str);
private:
char* m_pData;
};
请实现其赋值运算符的重载函数,要求异常安全,即当对一个对象进行赋值时发生异常,对象的状态不能改变。
分析:首先我们来看一般C++教科书上给出的赋值运算符的重载函数:
CMyString& CMyString::operator =(const CMyString &str)
{
if(this == &str)
return *this;
delete []m_pData;
m_pData = NULL;
m_pData = new char[strlen(str.m_pData) + 1];
strcpy(m_pData, str.m_pData);
return *this;
}
我们知道,在分配内存时有可能发生异常。当执行语句
new char[strlen(str.m_pData) + 1]发生异常时,程序将从该赋值运算符的重载函数退出不再执行。注意到这个时候语句delete []m_pData已经执行了。也就是说赋值操作没有完成,但原来对象的状态已经改变。也就是说不满足题目的异常安全的要求。
为了满足异常安全这个要求,一个简单的办法是掉换new、delete的顺序。先把内存new出来用一个临时指针保存起来,只有这个语句正常执行完成之后再执行delete。这样就能够保证异常安全了。
下面给出的是一个更加优雅的实现方案:
CMyString& CMyString::operator =(const CMyString &str)
{
if(this != &str)
{
CMyString strTemp(str);
char* pTemp = strTemp.m_pData;
strTemp.m_pData = m_pData;
m_pData = pTemp;
}
return *this;
}
该方案通过调用构造拷贝函数创建一个临时对象来分配内存。此时即使发生异常,对原来对象的状态没有影响。交换临时对象和需要赋值的对象的字符串指针之后,由于临时对象的生命周期结束,自动调用其析构函数释放需赋值对象的原来的字符串空间。整个函数不需要显式用到new、delete,内存的分配和释放都自动完成,因此代码显得比较优雅。
转自于:
http://www.cppblog.com/bellgrade/archive/2009/09/26/97321.html
实现stl string类——转自C++ how to program。
// String class definition with operator overloading.
#ifndef STRING_H
#define STRING_H
#include <iostream>
using std::ostream;
using std::istream;
class String
{
friend ostream &operator<<( ostream &, const String & );
friend istream &operator>>( istream &, String & );
public:
String( const char * = "" ); // conversion/default constructor
String( const String & ); // copy constructor
~String(); // destructor
const String &operator=( const String & ); // assignment operator
const String &operator+=( const String & ); // concatenation operator
bool operator!() const; // is String empty?
bool operator==( const String & ) const; // test s1 == s2
bool operator<( const String & ) const; // test s1 < s2
// test s1 != s2
bool operator!=( const String &right ) const
{
return !( *this == right );
} // end function operator!=
// test s1 > s2
bool operator>( const String &right ) const
{
return right < *this;
} // end function operator>
// test s1 <= s2
bool operator<=( const String &right ) const
{
return !( right < *this );
} // end function operator <=
// test s1 >= s2
bool operator>=( const String &right ) const
{
return !( *this < right );
} // end function operator>=
char &operator[]( int ); // subscript operator (modifiable lvalue)
char operator[]( int ) const; // subscript operator (rvalue)
String operator()( int, int = 0 ) const; // return a substring
int getLength() const; // return string length
private:
int length; // string length (not counting null terminator)
char *sPtr; // pointer to start of pointer-based string
void setString( const char * ); // utility function
}; // end class String
#endif
源文件#ifndef STRING_H
#define STRING_H
#include <iostream>
using std::ostream;
using std::istream;
class String
{
friend ostream &operator<<( ostream &, const String & );
friend istream &operator>>( istream &, String & );
public:
String( const char * = "" ); // conversion/default constructor
String( const String & ); // copy constructor
~String(); // destructor
const String &operator=( const String & ); // assignment operator
const String &operator+=( const String & ); // concatenation operator
bool operator!() const; // is String empty?
bool operator==( const String & ) const; // test s1 == s2
bool operator<( const String & ) const; // test s1 < s2
// test s1 != s2
bool operator!=( const String &right ) const
{
return !( *this == right );
} // end function operator!=
// test s1 > s2
bool operator>( const String &right ) const
{
return right < *this;
} // end function operator>
// test s1 <= s2
bool operator<=( const String &right ) const
{
return !( right < *this );
} // end function operator <=
// test s1 >= s2
bool operator>=( const String &right ) const
{
return !( *this < right );
} // end function operator>=
char &operator[]( int ); // subscript operator (modifiable lvalue)
char operator[]( int ) const; // subscript operator (rvalue)
String operator()( int, int = 0 ) const; // return a substring
int getLength() const; // return string length
private:
int length; // string length (not counting null terminator)
char *sPtr; // pointer to start of pointer-based string
void setString( const char * ); // utility function
}; // end class String
#endif
// String class member-function and friend-function definitions.
#include <iostream>
using std::cerr;
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
#include <cstring> // strcpy and strcat prototypes
using std::strcmp;
using std::strcpy;
using std::strcat;
#include <cstdlib> // exit prototype
using std::exit;
#include "String.h" // String class definition
// conversion (and default) constructor converts char * to String
String::String( const char *s )
: length( ( s != 0 ) ? strlen( s ) : 0 )
{
cout << "Conversion (and default) constructor: " << s << endl;
setString( s ); // call utility function
} // end String conversion constructor
// copy constructor
String::String( const String © )
: length( copy.length )
{
cout << "Copy constructor: " << copy.sPtr << endl;
setString( copy.sPtr ); // call utility function
} // end String copy constructor
// Destructor
String::~String()
{
cout << "Destructor: " << sPtr << endl;
delete [] sPtr; // release pointer-based string memory
} // end ~String destructor
// overloaded = operator; avoids self assignment
const String &String::operator=( const String &right )
{
cout << "operator= called" << endl;
if ( &right != this ) // avoid self assignment
{
delete [] sPtr; // prevents memory leak
length = right.length; // new String length
setString( right.sPtr ); // call utility function
} // end if
else
cout << "Attempted assignment of a String to itself" << endl;
return *this; // enables cascaded assignments
} // end function operator=
// concatenate right operand to this object and store in this object
const String &String::operator+=( const String &right )
{
size_t newLength = length + right.length; // new length
char *tempPtr = new char[ newLength + 1 ]; // create memory
strcpy( tempPtr, sPtr ); // copy sPtr
strcpy( tempPtr + length, right.sPtr ); // copy right.sPtr
delete [] sPtr; // reclaim old space
sPtr = tempPtr; // assign new array to sPtr
length = newLength; // assign new length to length
return *this; // enables cascaded calls
} // end function operator+=
// is this String empty?
bool String::operator!() const
{
return length == 0;
} // end function operator!
// Is this String equal to right String?
bool String::operator==( const String &right ) const
{
return strcmp( sPtr, right.sPtr ) == 0;
} // end function operator==
// Is this String less than right String?
bool String::operator<( const String &right ) const
{
return strcmp( sPtr, right.sPtr ) < 0;
} // end function operator<
// return reference to character in String as a modifiable lvalue
char &String::operator[]( int subscript )
{
// test for subscript out of range
if ( subscript < 0 || subscript >= length )
{
cerr << "Error: Subscript " << subscript
<< " out of range" << endl;
exit( 1 ); // terminate program
} // end if
return sPtr[ subscript ]; // non-const return; modifiable lvalue
} // end function operator[]
// return reference to character in String as rvalue
char String::operator[]( int subscript ) const
{
// test for subscript out of range
if ( subscript < 0 || subscript >= length )
{
cerr << "Error: Subscript " << subscript
<< " out of range" << endl;
exit( 1 ); // terminate program
} // end if
return sPtr[ subscript ]; // returns copy of this element
} // end function operator[]
// return a substring beginning at index and of length subLength
String String::operator()( int index, int subLength ) const
{
// if index is out of range or substring length < 0,
// return an empty String object
if ( index < 0 || index >= length || subLength < 0 )
return ""; // converted to a String object automatically
// determine length of substring
int len;
if ( ( subLength == 0 ) || ( index + subLength > length ) )
len = length - index;
else
len = subLength;
// allocate temporary array for substring and
// terminating null character
char *tempPtr = new char[ len + 1 ];
// copy substring into char array and terminate string
strncpy( tempPtr, &sPtr[ index ], len );
tempPtr[ len ] = '\0';
// create temporary String object containing the substring
String tempString( tempPtr );
delete [] tempPtr; // delete temporary array
return tempString; // return copy of the temporary String
} // end function operator()
// return string length
int String::getLength() const
{
return length;
} // end function getLength
// utility function called by constructors and operator=
void String::setString( const char *string2 )
{
sPtr = new char[ length + 1 ]; // allocate memory
if ( string2 != 0 ) // if string2 is not null pointer, copy contents
strcpy( sPtr, string2 ); // copy literal to object
else // if string2 is a null pointer, make this an empty string
sPtr[ 0 ] = '\0'; // empty string
} // end function setString
// overloaded output operator
ostream &operator<<( ostream &output, const String &s )
{
output << s.sPtr;
return output; // enables cascading
} // end function operator<<
// overloaded input operator
istream &operator>>( istream &input, String &s )
{
char temp[ 100 ]; // buffer to store input
input >> setw( 100 ) >> temp;
s = temp; // use String class assignment operator
return input; // enables cascading
} // end function operator>>
***********************************测试的代码****************************************************#include <iostream>
using std::cerr;
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
#include <cstring> // strcpy and strcat prototypes
using std::strcmp;
using std::strcpy;
using std::strcat;
#include <cstdlib> // exit prototype
using std::exit;
#include "String.h" // String class definition
// conversion (and default) constructor converts char * to String
String::String( const char *s )
: length( ( s != 0 ) ? strlen( s ) : 0 )
{
cout << "Conversion (and default) constructor: " << s << endl;
setString( s ); // call utility function
} // end String conversion constructor
// copy constructor
String::String( const String © )
: length( copy.length )
{
cout << "Copy constructor: " << copy.sPtr << endl;
setString( copy.sPtr ); // call utility function
} // end String copy constructor
// Destructor
String::~String()
{
cout << "Destructor: " << sPtr << endl;
delete [] sPtr; // release pointer-based string memory
} // end ~String destructor
// overloaded = operator; avoids self assignment
const String &String::operator=( const String &right )
{
cout << "operator= called" << endl;
if ( &right != this ) // avoid self assignment
{
delete [] sPtr; // prevents memory leak
length = right.length; // new String length
setString( right.sPtr ); // call utility function
} // end if
else
cout << "Attempted assignment of a String to itself" << endl;
return *this; // enables cascaded assignments
} // end function operator=
// concatenate right operand to this object and store in this object
const String &String::operator+=( const String &right )
{
size_t newLength = length + right.length; // new length
char *tempPtr = new char[ newLength + 1 ]; // create memory
strcpy( tempPtr, sPtr ); // copy sPtr
strcpy( tempPtr + length, right.sPtr ); // copy right.sPtr
delete [] sPtr; // reclaim old space
sPtr = tempPtr; // assign new array to sPtr
length = newLength; // assign new length to length
return *this; // enables cascaded calls
} // end function operator+=
// is this String empty?
bool String::operator!() const
{
return length == 0;
} // end function operator!
// Is this String equal to right String?
bool String::operator==( const String &right ) const
{
return strcmp( sPtr, right.sPtr ) == 0;
} // end function operator==
// Is this String less than right String?
bool String::operator<( const String &right ) const
{
return strcmp( sPtr, right.sPtr ) < 0;
} // end function operator<
// return reference to character in String as a modifiable lvalue
char &String::operator[]( int subscript )
{
// test for subscript out of range
if ( subscript < 0 || subscript >= length )
{
cerr << "Error: Subscript " << subscript
<< " out of range" << endl;
exit( 1 ); // terminate program
} // end if
return sPtr[ subscript ]; // non-const return; modifiable lvalue
} // end function operator[]
// return reference to character in String as rvalue
char String::operator[]( int subscript ) const
{
// test for subscript out of range
if ( subscript < 0 || subscript >= length )
{
cerr << "Error: Subscript " << subscript
<< " out of range" << endl;
exit( 1 ); // terminate program
} // end if
return sPtr[ subscript ]; // returns copy of this element
} // end function operator[]
// return a substring beginning at index and of length subLength
String String::operator()( int index, int subLength ) const
{
// if index is out of range or substring length < 0,
// return an empty String object
if ( index < 0 || index >= length || subLength < 0 )
return ""; // converted to a String object automatically
// determine length of substring
int len;
if ( ( subLength == 0 ) || ( index + subLength > length ) )
len = length - index;
else
len = subLength;
// allocate temporary array for substring and
// terminating null character
char *tempPtr = new char[ len + 1 ];
// copy substring into char array and terminate string
strncpy( tempPtr, &sPtr[ index ], len );
tempPtr[ len ] = '\0';
// create temporary String object containing the substring
String tempString( tempPtr );
delete [] tempPtr; // delete temporary array
return tempString; // return copy of the temporary String
} // end function operator()
// return string length
int String::getLength() const
{
return length;
} // end function getLength
// utility function called by constructors and operator=
void String::setString( const char *string2 )
{
sPtr = new char[ length + 1 ]; // allocate memory
if ( string2 != 0 ) // if string2 is not null pointer, copy contents
strcpy( sPtr, string2 ); // copy literal to object
else // if string2 is a null pointer, make this an empty string
sPtr[ 0 ] = '\0'; // empty string
} // end function setString
// overloaded output operator
ostream &operator<<( ostream &output, const String &s )
{
output << s.sPtr;
return output; // enables cascading
} // end function operator<<
// overloaded input operator
istream &operator>>( istream &input, String &s )
{
char temp[ 100 ]; // buffer to store input
input >> setw( 100 ) >> temp;
s = temp; // use String class assignment operator
return input; // enables cascading
} // end function operator>>
// String class test program.
#include <iostream>
using std::cout;
using std::endl;
using std::boolalpha;
#include "String.h"
int main()
{
String s1( "happy" );
String s2( " birthday" );
String s3;
// test overloaded equality and relational operators
cout << "s1 is \"" << s1 << "\"; s2 is \"" << s2
<< "\"; s3 is \"" << s3 << '\"'
<< boolalpha << "\n\nThe results of comparing s2 and s1:"
<< "\ns2 == s1 yields " << ( s2 == s1 )
<< "\ns2 != s1 yields " << ( s2 != s1 )
<< "\ns2 > s1 yields " << ( s2 > s1 )
<< "\ns2 < s1 yields " << ( s2 < s1 )
<< "\ns2 >= s1 yields " << ( s2 >= s1 )
<< "\ns2 <= s1 yields " << ( s2 <= s1 );
// test overloaded String empty (!) operator
cout << "\n\nTesting !s3:" << endl;
if ( !s3 )
{
cout << "s3 is empty; assigning s1 to s3;" << endl;
s3 = s1; // test overloaded assignment
cout << "s3 is \"" << s3 << "\"";
} // end if
// test overloaded String concatenation operator
cout << "\n\ns1 += s2 yields s1 = ";
s1 += s2; // test overloaded concatenation
cout << s1;
// test conversion constructor
cout << "\n\ns1 += \" to you\" yields" << endl;
s1 += " to you"; // test conversion constructor
cout << "s1 = " << s1 << "\n\n";
// test overloaded function call operator () for substring
cout << "The substring of s1 starting at\n"
<< "location 0 for 14 characters, s1(0, 14), is:\n"
<< s1( 0, 14 ) << "\n\n";
// test substring "to-end-of-String" option
cout << "The substring of s1 starting at\n"
<< "location 15, s1(15), is: "
<< s1( 15 ) << "\n\n";
// test copy constructor
String *s4Ptr = new String( s1 );
cout << "\n*s4Ptr = " << *s4Ptr << "\n\n";
// test assignment (=) operator with self-assignment
cout << "assigning *s4Ptr to *s4Ptr" << endl;
*s4Ptr = *s4Ptr; // test overloaded assignment
cout << "*s4Ptr = " << *s4Ptr << endl;
// test destructor
delete s4Ptr;
// test using subscript operator to create a modifiable lvalue
s1[ 0 ] = 'H';
s1[ 6 ] = 'B';
cout << "\ns1 after s1[0] = 'H' and s1[6] = 'B' is: "
<< s1 << "\n\n";
// test subscript out of range
cout << "Attempt to assign 'd' to s1[30] yields:" << endl;
s1[ 30 ] = 'd'; // ERROR: subscript out of range
return 0;
} // end main
以下是一个自己写的可以使用的版本:#include <iostream>
using std::cout;
using std::endl;
using std::boolalpha;
#include "String.h"
int main()
{
String s1( "happy" );
String s2( " birthday" );
String s3;
// test overloaded equality and relational operators
cout << "s1 is \"" << s1 << "\"; s2 is \"" << s2
<< "\"; s3 is \"" << s3 << '\"'
<< boolalpha << "\n\nThe results of comparing s2 and s1:"
<< "\ns2 == s1 yields " << ( s2 == s1 )
<< "\ns2 != s1 yields " << ( s2 != s1 )
<< "\ns2 > s1 yields " << ( s2 > s1 )
<< "\ns2 < s1 yields " << ( s2 < s1 )
<< "\ns2 >= s1 yields " << ( s2 >= s1 )
<< "\ns2 <= s1 yields " << ( s2 <= s1 );
// test overloaded String empty (!) operator
cout << "\n\nTesting !s3:" << endl;
if ( !s3 )
{
cout << "s3 is empty; assigning s1 to s3;" << endl;
s3 = s1; // test overloaded assignment
cout << "s3 is \"" << s3 << "\"";
} // end if
// test overloaded String concatenation operator
cout << "\n\ns1 += s2 yields s1 = ";
s1 += s2; // test overloaded concatenation
cout << s1;
// test conversion constructor
cout << "\n\ns1 += \" to you\" yields" << endl;
s1 += " to you"; // test conversion constructor
cout << "s1 = " << s1 << "\n\n";
// test overloaded function call operator () for substring
cout << "The substring of s1 starting at\n"
<< "location 0 for 14 characters, s1(0, 14), is:\n"
<< s1( 0, 14 ) << "\n\n";
// test substring "to-end-of-String" option
cout << "The substring of s1 starting at\n"
<< "location 15, s1(15), is: "
<< s1( 15 ) << "\n\n";
// test copy constructor
String *s4Ptr = new String( s1 );
cout << "\n*s4Ptr = " << *s4Ptr << "\n\n";
// test assignment (=) operator with self-assignment
cout << "assigning *s4Ptr to *s4Ptr" << endl;
*s4Ptr = *s4Ptr; // test overloaded assignment
cout << "*s4Ptr = " << *s4Ptr << endl;
// test destructor
delete s4Ptr;
// test using subscript operator to create a modifiable lvalue
s1[ 0 ] = 'H';
s1[ 6 ] = 'B';
cout << "\ns1 after s1[0] = 'H' and s1[6] = 'B' is: "
<< s1 << "\n\n";
// test subscript out of range
cout << "Attempt to assign 'd' to s1[30] yields:" << endl;
s1[ 30 ] = 'd'; // ERROR: subscript out of range
return 0;
} // end main
#include <iostream>#include <map>#include <algorithm>#include <limits.h>#include <assert.h>#include <stack>#include <string>#include <unordered_map>#include <sstream>#include <iostream>#include <time.h>#include <stdio.h>using namespace std;class CMyString{public: CMyString(char* pData = NULL); CMyString(const CMyString& str); virtual ~CMyString(void); CMyString& operator = (const CMyString& str); bool operator == (const CMyString& str) const; CMyString& operator += (const CMyString& str);private: char* mData;};CMyString::CMyString(char* pData) { if (pData == NULL) { mData = new char[1]; mData[0] = '\0'; } else { int len = strlen(pData); mData = new char[len + 1]; strcpy(mData,pData); }}CMyString::CMyString(const CMyString& str) { int len = strlen(str.mData); mData = new char[len + 1]; strcpy(mData, str.mData);}CMyString::~CMyString() { delete [] mData;}CMyString& CMyString::operator =(const CMyString &str){ if(this != &str) { CMyString strTemp(str); char* pTemp = strTemp.mData; strTemp.mData = mData; mData = pTemp; } return *this;}bool CMyString::operator == (const CMyString& str) const{ return strcmp(mData,str.mData) == 0;}CMyString& CMyString::operator+=(const CMyString& str) { int len1= strlen(mData), len2 = strlen(str.mData), len = len1 + len2; char* tmp = new char[len + 1]; strcpy(tmp, mData); strcpy(tmp+len1, str.mData); delete []mData; mData = tmp; return *this;}int main() { CMyString str1 = "abcd"; CMyString str2 = "abcd"; CMyString str3 = "abcd"; if (str1 == str2) str3 += str2; str2 = str3; return 0;}
0 0
- 异常安全的赋值运算符重载函数 C++ String实现
- 赋值运算符的重载函数,要求异常安全
- 异常安全的CMyString赋值运算符函数重载
- 异常安全的赋值运算符重载函数
- 异常安全的赋值运算符函数
- 程序员面试题精选(30):异常安全的赋值运算符重载函数
- 程序员面试题精选100题(30)-异常安全的赋值运算符重载函数
- 赋值运算符函数异常安全
- 实现字符串类String的设计,实现赋值运算符重载函数,默认、一般、拷贝构造函数,析构函数
- C++异常安全的赋值运算符重载 【微软面试100题 第五十五题】
- String类的构造函数、析构函数、拷贝构造函数、赋值运算符重载
- 赋值运算符的重载函数
- 赋值运算符的重载函数
- 十八、运算符重载(二)++运算符重载、!运算符重载、赋值运算符重载、Integer和String的初步实现
- 赋值运算符重载函数[C/C++/C#]
- 赋值运算符重载函数
- 赋值运算符重载函数
- C++赋值构造函数和赋值运算符的重载
- underscore学习笔记—链式语法/Chaining
- WPF--的BeginStoryboard用法
- hibernate update和delete方法无效
- JPEG图像的解压缩操作
- 算法作业2
- 异常安全的赋值运算符重载函数 C++ String实现
- KVM优化
- SQL SERVER的锁机制(四)——概述(各种事务隔离级别发生的影响)
- ssh 完整
- Static, Shared Dynamic and Loadable Linux Libraries
- 分多文件完成的循环计算完整版
- 如何用Revit API获取Conduit、FlexPipe的类型
- java webservice使用Ksoap2接收返回的数组
- Linux iptables 转向重定向配置实例