2. 如果第一个操作数为负数,那么得到的模也为负数;如果第一个操作数为正数,那么得到的模也为正数。
3. 取模公式:a % b == a - (a/b) * b
void * __cdecl memcpy (
void * dst,
const void * src,
size_t count
)
{
void * ret = dst;
#if defined (_M_IA64)
{
extern void RtlMoveMemory( void *, const void *, size_t count );
RtlMoveMemory( dst, src, count );
}
#else /* defined (_M_IA64) */
/*
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
#endif /* defined (_M_IA64) */
return(ret);
}
再来看看coreutils中的实现:
void *
memcpy (void *destaddr, void const *srcaddr, size_t len)
{
char *dest = destaddr;
char const *src = srcaddr;
while (len-- > 0)
*dest++ = *src++;
return destaddr;
}
再来看Linux中实现:
void *memcpy(void *dest, const void *src, size_t count)
{
char *tmp = dest;
const char *s = src;
while (count--)
*tmp++ = *s++;
return dest;
}
子类的拷贝构造函数要调用父类的拷贝构造函数
子类的重载赋值运算符要调用父类的重载赋值运算符
/*
子类的拷贝构造函数要调用父类的拷贝构造函数
子类的重载赋值运算符要调用父类的重载赋值运算符
*/
class Parent
{
public:
Parent(){}
Parent(int a):m_a(a)
{
p = new int[m_a];
}
//拷贝构造函数
Parent(const Parent &oth)
{
m_a = oth.m_a;
p = new int[m_a];
memcpy(p, oth.p, sizeof(p));
}
//重载赋值运算符
Parent &operator = (const Parent& oth)
{
if (this == &oth)
{
return *this;
}
m_a = oth.m_a;
delete []p;
p = new int[m_a];
memcpy(p, oth.p, sizeof(p));
}
virtual ~Parent()
{
delete []p;
}
private:
int m_a;
int *p;
};
class Child : public Parent
{
public:
Child(){}
Child(int a, string str):Parent(a),m_str(str){}
//拷贝构造函数
Child(const Child &oth):Parent(oth),m_str(oth.m_str)//调用父类的拷贝构造函数
{}
//重载赋值运算符
Child &operator = (const Child &oth)
{
Parent::operator =(oth);//调用父类的重载赋值运算符
m_str = oth.m_str;
}
~Child(){}
private:
string m_str;
};
int main()
{
Parent parent(10);
Child child(2,"wangyang");
}