]]>
2009q?8?8?星期?11:26
|
有了malloc/freeZ么还要new/delete Q?br> malloc与free是C++/C语言的标准库函数Qnew/delete是C++的运符。它们都可用于申请动态内存和释放内存?br> |
]]>
class String
{
public:
String(const char *str=NULL); //构造函?/span>
String(const String &other); //拯构造函?/span>
~String(void); //析构函数
String& operator=(const String &other); //{号操作W重?/span>
ShowString();
private:
char *m_data; //指针
};
String::~String()
{
delete [] m_data; //析构函数Q释攑֜址I间
}
String::String(const char *str)
{
if (str==NULL)//当初始化串不存在的时候，?/span>m_data甌一个空间存?/span>'\0'Q?/span>
{
m_data=new char[1];
*m_data='\0';
}
else//当初始化串存在的时候，?/span>m_data甌同样大小的空间存放该Ԍ
{
int length=strlen(str);
m_data=new char[length+1];
strcpy(m_data,str);
}
}
String::String(const String &other)//拯构造函敎ͼ功能与构造函数类伹{?/span>
{
int length=strlen(other.m_data);
m_data=new [length+1];
strcpy(m_data,other.m_data);
}
String& String::operator =(const String &other)
{
if (this==&other)//当地址相同Ӟ直接q回Q?/span>
return *this;
delete [] m_data;//当地址不相同时Q删除原来申LI间Q重新开始构造；
int length=sizeof(other.m_data);
m_data=new [length+1];
strcpy(m_data,other.m_data);
return *this;
}
String::ShowString()//׃m_data是私有成员，对象只能通过public成员函数来访问；
{
cout<<this->m_data<<endl;
}
main()
{
String AD;
char * p="ABCDE";
String B(p);
AD.ShowString();
AD=B;
AD.ShowString();
}
]]>
class String
{
public:
String(const char *str=NULL); //构造函?/span>
String(const String &other); //拯构造函?/span>
~String(void); //析构函数
String& operator=(const String &other); //{号操作W重?/span>
ShowString();
private:
char *m_data; //指针
};
String::~String()
{
delete [] m_data; //析构函数Q释攑֜址I间
}
String::String(const char *str)
{
if (str==NULL)//当初始化串不存在的时候，?/span>m_data甌一个空间存?/span>'\0'Q?/span>
{
m_data=new char[1];
*m_data='\0';
}
else//当初始化串存在的时候，?/span>m_data甌同样大小的空间存放该Ԍ
{
int length=strlen(str);
m_data=new char[length+1];
strcpy(m_data,str);
}
}
String::String(const String &other)//拯构造函敎ͼ功能与构造函数类伹{?/span>
{
int length=strlen(other.m_data);
m_data=new [length+1];
strcpy(m_data,other.m_data);
}
String& String::operator =(const String &other)
{
if (this==&other)//当地址相同Ӟ直接q回Q?/span>
return *this;
delete [] m_data;//当地址不相同时Q删除原来申LI间Q重新开始构造；
int length=sizeof(other.m_data);
m_data=new [length+1];
strcpy(m_data,other.m_data);
return *this;
}
String::ShowString()//׃m_data是私有成员，对象只能通过public成员函数来访问；
{
cout<<this->m_data<<endl;
}
main()
{
String AD;
char * p="ABCDE";
String B(p);
AD.ShowString();
AD=B;
AD.ShowString();
}
]]>
dynamic_cast: 通常在基cdzcM间{换时使用,run-time cast
const_cast: 主要针对const和volatile的{?
static_cast: 一般的转换Qno run-time check.通常Q如果你不知道该用哪个，qq个?
reinterpret_cast: 用于q行没有M兌之间的{换，比如一个字W指针{换ؓ一个整形数?br>
http://blog.csdn.net/goodluckyxl/archive/2005/01/19/259851.aspx
强制转化四种cd可能很多人都常常忽略p我一P但是有时q是比较有用的。不了解的徏议看看，一些机制我也不是十分了解，只是一些用法写出来让大家看看?br> 2004-11-27 9:00
强制转化无论从语法还是语意上看，都是c++中最隄的特征之一。但是基于c风格的{化的语义的不明确性及其一些潜在问题。强制类型{化最l还是被c++接受了?br>1.static_castq算W号
static_cast<T>(e),stroustrup让我们可以把它看成隐含{换的昄的逆运。这个是有一定道理的Q基于隐式{化的对象cd我们可以使用static_cast转化q算W号。它是静态的，无法q行时检类型，在承中ؓH出?br>使用范围
<1>用于所有系l类型之间{化，不能用于pȝcd指针cd转化
double t_d = 0;
int t_i= static_cast<int>(t_d); //是合法的转化
而企囑ְdouble*->int*是不允许?br><2>用于l承cM间的转化Q含指针Q，不能用于其他没有隐式转化的对象类型之间的转化
l承举例:
class x
{
};
class y: public x
{
};
使用:x t_o_x;
y t_o_y = static_cast<y>(t_o_x); //x* y*转化也可以进行因为x,yl承?br>//p，cd可以自动隐式转化使用
隐式转化举例:
class x
{
};
class y
{
public:
y( x i_x ) {}
};
x t_o_x;
y t_o_y = static_cast<y>(t_o_x); //大家看到y构造函数可以对于xcd隐式转化
//所以可以将x->yQ如果企囑ְy->x会报?br>2.reinterpret_cast q算
主要用于对于cd指针cd的强制{化，some_type* -> special_type*q样转化Q类型信息可以是不完全的。它允许Q意指针{化到其他cd指针Q也允许L整数cdCQ意指针类型{?BT)。这样导致的l果是极其不安全的，不能安全的应用于其他目的Q除非{化到原来cd?br><1> 使用所有整形可以{化ؓLcd的指?指针?字节的long的东东，那么机器p为同cd是可以转化)
int c;
x* p = reinterpret_cast<x*>(c); //x是自定义的Q意类型，当然包括pȝcd
<2> 可以对于Lcd指针之间转化
y* c;
x* p = reinterpret_cast<x*>(c);//x,y代表所有自定义或系l类?br>大家可以看到reinterpret_cast的{化是极度的不负责ȝQ他只管转化不检是否可以{化?br><3> const_castq算W号
q个很简单从名字大家可以看出来，仅仅ZL或着加上const修饰W号。但是对于本w定义时为const的类型，即你去掉const性，在你操作q片内容时候也要小心，只能r不能w操作Q否则还是会出错?br>const char* p = "123";
char* c = const_cast<char*>(p);
c[0] = 1; //表面上通过~译L了const性，但是操作其地址时系l依然不允许q?br>//么做。这是一个漏z吧
<4> dynamic_castq算W号
Scott Mayers其描述为用来执行承体pMQ安全的向下转型或者跨p{型动作。也是说你可以Q用dynamic_cast?指向base class的指针或引用转型?指向子类的对象的指针或引用?br>class B {}; //polymorphiccd含virtual才能dynamic_cast
class D: public B {}
void f( B* pb )
{
D* pd1 = dynamic_cast<D*>(pb);//如果pb为dcd正确q回Q如果不是返?
D* pd2 = static_cast<D*>(pb); //不管怎么样都q回指针有可能指向不合适的?br>//象，因ؓstatic仅仅静态检，不能得到q?br>//行时对象的信息是否真正ؓDcd
}
http://www.vckbase.com/document/viewdoc/?id=1651
static_cast<>揭密
作者：Sam NG
译者：刀?/a>
原文链接Q?a >What static_cast<> is actually doing
本文讨论static_cast<> ?reinterpret_cast<>?
介绍
大多E序员在学C++前都学过CQƈ且习惯于C风格Q类型）转换。当写C++Q程序）Ӟ有时候我们在使用static_cast<>?reinterpret_cast<>时可能会有点模糊。在本文中，我将说明static_cast<>实际上做了什么，q且指出一些将会导致错误的情况?br>
泛型QGeneric TypesQ?/strong>
float f = 12.3;而言之，static_cast<> 尝试{换，举例来说Q如float-?integerQ而reinterpret_cast<>单改变编译器的意N新考虑那个对象作ؓ另一cd?br>
float* pf = &f;
// static cast<>
// 成功~译, n = 12
int n = static_cast<int>(f);
// 错误,指向的类型是无关的（译注Q即指针变量pf是floatcdQ现在要被{换ؓintcdQ?br> //int* pn = static_cast<int*>(pf);
//成功~译
void* pv = static_cast<void*>(pf);
//成功~译, 但是 *pn2是无意义的内存（rubbishQ?br>
int* pn2 = static_cast<int*>(pv);
// reinterpret_cast<>
//错误,~译器知道你应该调用static_cast<>
//int i = reinterpret_cast<int>(f);
//成功~译, 但是 *pn 实际上是无意义的内存,?*pn2一?br>
int* pi = reinterpret_cast<int*>(pf);
指针cdQPointer TypesQ?/strong>
指针转换有点复杂Q我们将在本文的剩余部分使用下面的类Q?br>
class CBaseX情况1Q两个无关的cM间的转换
{
public:
int x;
CBaseX() { x = 10; }
void foo() { printf("CBaseX::foo() x=%d\n", x); }
};
class CBaseY
{
public:
int y;
int* py;
CBaseY() { y = 20; py = &y; }
void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py);
}
};
class CDerived : public CBaseX, public CBaseY
{
public:
int z;
};
// Convert between CBaseX* and CBaseY*正如我们在泛型例子中所认识到的Q如果你试转换一个对象到另一个无关的cstatic_cast<>失败，而reinterpret_cast<>L成功“ƺ骗”~译器：那个对象是那个无关cR?br>
// CBaseX* ?CBaseY*之间的{?br>
CBaseX* pX = new CBaseX();
// Error, types pointed to are unrelated
// 错误Q?cd指向是无关的
// CBaseY* pY1 = static_cast<CBaseY*>(pX);
// Compile OK, but pY2 is not CBaseX
// 成功~译, 但是 pY2 不是CBaseX
CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);
// System crash!!
// pȝ崩溃!!
// pY2->bar();
情况2Q{换到相关的类
1. CDerived* pD = new CDerived();
2. printf("CDerived* pD = %x\n", (int)pD);
3.
4. // static_cast<> CDerived* -> CBaseY* -> CDerived*
//成功~译Q隐式static_cast<>转换
5. CBaseY* pY1 = pD;
6. printf("CBaseY* pY1 = %x\n", (int)pY1);
// 成功~译, 现在 pD1 = pD
7. CDerived* pD1 = static_cast<CDerived*>(pY1);
8. printf("CDerived* pD1 = %x\n", (int)pD1);
9.
10. // reinterpret_cast
// 成功~译, 但是 pY2 不是 CBaseY*
11. CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);
12. printf("CBaseY* pY2 = %x\n", (int)pY2);
13.
14. // 无关?static_cast<>
15. CBaseY* pY3 = new CBaseY();
16. printf("CBaseY* pY3 = %x\n", (int)pY3);
// 成功~译,管 pY3 只是一?"?CBaseY()"
17. CDerived* pD3 = static_cast<CDerived*>(pY3);
18. printf("CDerived* pD3 = %x\n", (int)pD3);
---------------------- 输出 ---------------------------
CDerived* pD = 392fb8
CBaseY* pY1 = 392fbc
CDerived* pD1 = 392fb8
CBaseY* pY2 = 392fb8
CBaseY* pY3 = 390ff0
CDerived* pD3 = 390fec
注意Q在CDerived*用隐?static_cast<>转换到CBaseY*Q第5行）Ӟl果是（指向QCDerived*Q的指针向后Q?偏移?Q个字节Q（译注Q?为intcd在内存中所占字节数Q。ؓ了知道static_cast<> 实际如何Q我们不得不要来看一下CDerived的内存布局?/p>
CDerived的内存布局QMemory LayoutQ?/strong>
如图所C，CDerived的内存布局包括两个对象QCBaseX ?CBaseYQ编译器也知道这一炏V因此，当你CDerived* 转换?CBaseY*Ӟ它给指针d4个字节，同时当你CBaseY*转换到CDerived*Ӟ它给指针减去4。然而，甚至它即便不是一个CDerived你也可以q样做?br>当然Q这个问题只在如果你做了多承时发生。在你将CDerived转换 ?CBaseX时static_cast<> ?reinterpret_cast<>是没有区别的?br>
情况3Qvoid*之间的向前和向后转换
因ؓM指针可以被{换到void*Q而void*可以被向后{换到M指针Q对于static_cast<> ?reinterpret_cast<>转换都可以这样做Q，如果没有心处理的话错误可能发生?br>
CDerived* pD = new CDerived();
printf("CDerived* pD = %x\n", (int)pD);
CBaseY* pY = pD; // 成功~译, pY = pD + 4
printf("CBaseY* pY = %x\n", (int)pY);
void* pV1 = pY; //成功~译, pV1 = pY
printf("void* pV1 = %x\n", (int)pV1);
// pD2 = pY, 但是我们预期 pD2 = pY - 4
CDerived* pD2 = static_cast<CDerived*>(pV1);
printf("CDerived* pD2 = %x\n", (int)pD2);
// pȝ崩溃
// pD2->bar();
---------------------- 输出 ---------------------------
CDerived* pD = 392fb8
CBaseY* pY = 392fbc
void* pV1 = 392fbc
CDerived* pD2 = 392fbc
一旦我们已l{换指针ؓvoid*Q我们就不能L其转换回原cR在上面的例子中Q从一个void* q回CDerived*的唯一Ҏ是将其{换ؓCBaseY*然后再{换ؓCDerived*?
但是如果我们不能定它是CBaseY* q是 CDerived*Q这时我们不得不用dynamic_cast<> 或typeid[2]?br>
注释Q?/strong>
1. dynamic_cast<>Q从另一斚w来说Q可以防止一个泛型CBaseY* 被{换到CDerived*?br>2. dynamic_cast<>需要类成ؓ多态，卛_?#8220;?#8221;函数Qƈ因此而不能成为void*?br>参考：
1. [MSDN] C++ Language Reference -- Casting
2. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs
3. Juan Soulie, C++ Language Tutorial: Type Casting
推荐链接Q?/strong>如何在运行时定对象cdQRTTIQ?/a>
]]>