linux C++ day07

最新推荐文章于 2024-06-11 20:49:12 发布
最新推荐文章于 2024-06-11 20:49:12 发布
阅读量106 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40632341/article/details/104303378
版权

目录
支持+/-操作符的复数类
支持+=/-=操作符的复数类
支持-/~操作符的复数类
支持前++/–操作符的复数类
支持后++/–操作符的复数类
支持<<操作符的复数类
支持>>操作符的复数类
支持[]操作符的数组类
支持()操作符的平方类
简化版的智能指针类
auto_ptr的基本用法和局限
在基本类型和类类型之间做类型转换
重载new和delete操作符
1 支持+/-操作符的复数类
1.1 问题
定义一个复数类，类中包括两个私有的成员变量，m_r代表实部，m_i代表虚部，并重载+/-运算符，以实现复数的加法与减法运算，及显示运算结果。

1.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持+/-操作符的复数类

代码如下：

#include
class Complex
{
private:
double m_r;//实部
double m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex const operator+ (Complex const& rhs) const
{
return Complex (m_r + rhs.m_r, m_i + rhs.m_i);
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex const operator- (Complex const&, Complex const&);
};
Complex const operator- (Complex const& lhs, Complex const& rhs)
{
return Complex (lhs.m_r - rhs.m_r, lhs.m_i - rhs.m_i);
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2(4, 1);
Complex c3;
c3 = c1 + c2;
c3.show();

c3 = c1 - c2;
c3.show();

return 0;

}
上述代码中，以下代码：

Complex const operator+ (Complex const& rhs) const
{
    return Complex (m_r + rhs.m_r, m_i + rhs.m_i);
}

定义了复数类Complex的+运算符的重载函数。常函数以支持右值型左操作数，常参数以支持右值型右操作数，常返回值以支持右值型表达式的值。

上述代码中，以下代码：

Complex const operator- (Complex const& lhs, Complex const& rhs)
{
return Complex (lhs.m_r - rhs.m_r, lhs.m_i - rhs.m_i);
}
定义了复数类Complex的-运算符的全局函数。常第一参数以支持右值型左操作数，常第二参数以支持右值型右操作数，常返回值以支持右值型表达式的值。

上述代码中，以下代码：

friend Complex const operator- (Complex const&, Complex const&);

为了在一个全局操作符函数中直接访问其操作数类型的私有及保护成员，同时又不破坏其操作数类型的封装性，可以将该操作符函数声明为其操作数类型的友元。

1.3 完整代码
本案例的完整代码如下所示：

#include
class Complex
{
private:
double m_r;//实部
double m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex const operator+ (Complex const& rhs) const
{
return Complex (m_r + rhs.m_r, m_i + rhs.m_i);
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex const operator- (Complex const&, Complex const&);
};
Complex const operator- (Complex const& lhs, Complex const& rhs)
{
return Complex (lhs.m_r - rhs.m_r, lhs.m_i - rhs.m_i);
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2(4, 1);
Complex c3;
c3 = c1 + c2;
c3.show();

c3 = c1 - c2;
c3.show();

return 0;

}
2 支持+=/-=操作符的复数类
2.1 问题
定义一个复数类，类中包括两个私有的成员变量，m_r代表实部，m_i代表虚部，并重载+=/-=运算符，以实现复数的复合赋值运算，及显示运算结果。

2.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持+=/-=操作符的复数类

代码如下：

#include
class Complex
{
private:
double m_r;//实部
double m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex& operator+= (Complex const& rhs)
{
m_r += rhs.m_r;
m_i += rhs.m_i;
return *this;
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex& operator-= (Complex&, Complex const&);
};
Complex& operator-= (Complex& lhs, Complex const& rhs)
{
lhs.m_r -= rhs.m_r;
lhs.m_i -= rhs.m_i;
return lhs;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2(4, 1);
c1 += c2;
c1.show();

c1 -= c2;
c1.show();

return 0;

}
上述代码中，以下代码：

Complex& operator+= (Complex const& rhs)
{
    m_r += rhs.m_r;
    m_i += rhs.m_i;
    return *this;
}

定义了复数类Complex的+=运算符的重载函数。非常函数以支持左值型左操作数，常参数以支持右值型右操作数，非常返回值以支持左值型表达式的值，返回自引用即左操作数本身。

上述代码中，以下代码：

Complex& operator-= (Complex& lhs, Complex const& rhs)
{
lhs.m_r -= rhs.m_r;
lhs.m_i -= rhs.m_i;
return lhs;
}
定义了复数类Complex的-=运算符的全局函数。非常第一参数以支持左值型左操作数，常第二参数以支持右值型右操作数，非常返回值以支持左值型表达式的值，返回引用型第一参数即左操作数本身。

上述代码中，以下代码：

friend Complex const operator- (Complex const&, Complex const&);

为了在一个全局操作符函数中直接访问其操作数类型的私有及保护成员，同时又不破坏其操作数类型的封装性，可以将该操作符函数声明为其操作数类型的友元。

2.3 完整代码
本案例的完整代码如下所示：

#include
class Complex
{
private:
double m_r;//实部
double m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex& operator+= (Complex const& rhs)
{
m_r += rhs.m_r;
m_i += rhs.m_i;
return *this;
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex& operator-= (Complex&, Complex const&);
};
Complex& operator-= (Complex& lhs, Complex const& rhs)
{
lhs.m_r -= rhs.m_r;
lhs.m_i -= rhs.m_i;
return lhs;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2(4, 1);
c1 += c2;
c1.show();

c1 -= c2;
c1.show();

return 0;

}
3 支持-/~操作符的复数类
3.1 问题
定义一个复数类，类中包括两个私有的成员变量，m_r代表实部，m_i代表虚部，并重载-/~运算符，以实现复数的相反数和位反运算，及显示运算结果。

3.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持-/~操作符的复数类

代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex const operator- (void) const
{
return Complex (-m_r, -m_i);
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex const operator~ (Complex const&);
};
Complex const operator~ (Complex const& lhs)
{
return Complex (~lhs.m_r, ~lhs.m_i);
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2;
c2 = -c1;
c2.show();

c2 = ~c1;
c2.show();

return 0;

}
上述代码中，以下代码：

Complex const operator- (void) const
{
    return Complex (-m_r, -m_i);
}

定义了复数类Complex的-运算符的重载函数。常函数以支持右值型操作数，常返回值以支持右值型表达式的值。

上述代码中，以下代码：

Complex const operator~ (Complex const& lhs)
{
return Complex (~lhs.m_r, ~lhs.m_i);
}
定义了复数类Complex的~运算符的全局函数。

上述代码中，以下代码：

friend Complex const operator~ (Complex const&);

为了在一个全局操作符函数中直接访问其操作数类型的私有及保护成员，同时又不破坏其操作数类型的封装性，可以将该操作符函数声明为其操作数类型的友元。

3.3 完整代码
本案例的完整代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex const operator- (void) const
{
return Complex (-m_r, -m_i);
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex const operator~ (Complex const&);
};
Complex const operator~ (Complex const& lhs)
{
return Complex (~lhs.m_r, ~lhs.m_i);
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2;
c2 = -c1;
c2.show();

c2 = ~c1;
c2.show();

return 0;

}
4 支持前++/–操作符的复数类
4.1 问题
定义一个复数类，类中包括两个私有的成员变量，m_r代表实部，m_i代表虚部，并重载前++/–运算符，以实现复数的前置自增/前置自减运算，及显示运算结果。

4.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持前++/–操作符的复数类

代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex& operator++ (void)
{
++m_r;
++m_i;
return *this;
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex& operator-- (Complex&);
};
Complex& operator-- (Complex& opd)
{
–opd.m_r;
–opd.m_i;
return opd;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
++c1;
c1.show();
--c1;
c1.show();

return 0;

}
上述代码中，以下代码：

Complex& operator++ (void)
{
    ++m_r;
    ++m_i;
    return *this;
}

定义了复数类Complex的前置++运算符的重载函数。非常参数以支持左值型操作数，非常返回值以支持左值型表达式的值，返回自引用即操作数本身。

上述代码中，以下代码：

Complex& operator-- (Complex& opd)
{
–opd.m_r;
–opd.m_i;
return opd;
}
定义了复数类Complex的前置–运算符的全局函数。非常函数以支持左值型操作数，非常返回值以支持左值型表达式的值，返回自引用即操作数本身。

上述代码中，以下代码：

friend Complex& operator-- (Complex&);

为了在一个全局操作符函数中直接访问其操作数类型的私有及保护成员，同时又不破坏其操作数类型的封装性，可以将该操作符函数声明为其操作数类型的友元。

4.3 完整代码
本案例的完整代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex& operator++ (void)
{
++m_r;
++m_i;
return *this;
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex& operator-- (Complex&);
};
Complex& operator-- (Complex& opd)
{
–opd.m_r;
–opd.m_i;
return opd;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
++c1;
c1.show();
--c1;
c1.show();

return 0;

}
5 支持后++/–操作符的复数类
5.1 问题
定义一个复数类，类中包括两个私有的成员变量，m_r代表实部，m_i代表虚部，并重载后++/–运算符，以实现复数的后置自增/后置自减运算，及显示运算结果。

5.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持后++/–操作符的复数类

代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex const operator++ (int)
{
Complex old = *this;
++m_r;
++m_i;
return old;
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex const operator-- (Complex&, int);
};
Complex const operator-- (Complex& opd, int)
{
Complex old = opd;
–opd.m_r;
–opd.m_i;
return old;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2;
c2 = c1++;
c1.show();
c2.show();
c2 = c1--;
c1.show();
c2.show();

return 0;

}
上述代码中，以下代码：

Complex const operator++ (int)
{
    Complex old = *this;
    ++m_r;
    ++m_i;
    return old;
}

定义了复数类Complex的后置++运算符的重载函数。非常函数以支持左值型操作数，常返回值以支持右值型表达式的值，整型哑元参数以区别于前置自增。由于是后置自增运算，所以操作数应该先参与其他运算符的运算，然后再自增，这样就必须返回自增前的对象，即old，使自增前的对象与其它运算符运算。对于后置自增表达式，编译器在调用操作符函数时会多传一个整型参数，通过重载解析匹配到后缀操作符函数。

上述代码中，以下代码：

Complex const operator-- (Complex& opd, int)
{
Complex old = opd;
–opd.m_r;
–opd.m_i;
return old;
}
定义了复数类Complex的后置–运算符的全局函数。非常参数以支持左值型操作数，常返回值以支持右值型表达式的值，整型哑元参数以区别于前置自减。

上述代码中，以下代码：

friend Complex const operator-- (Complex&, int);

为了在一个全局操作符函数中直接访问其操作数类型的私有及保护成员，同时又不破坏其操作数类型的封装性，可以将该操作符函数声明为其操作数类型的友元。

5.3 完整代码
本案例的完整代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
Complex const operator++ (int)
{
Complex old = *this;
++m_r;
++m_i;
return old;
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend Complex const operator-- (Complex&, int);
};
Complex const operator-- (Complex& opd, int)
{
Complex old = opd;
–opd.m_r;
–opd.m_i;
return old;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
Complex c2;
c2 = c1++;
c1.show();
c2.show();
c2 = c1--;
c1.show();
c2.show();

return 0;

}
6 支持<<操作符的复数类
6.1 问题
定义一个复数类，类中包括两个私有的成员变量，m_r代表实部，m_i代表虚部，并重载<<输出流运算符，以实现复数的输出操作。

6.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持<<操作符的复数类

代码如下：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend std::ostream& operator<< (std::ostream&, Complex const&);
};
std::ostream& operator<< (std::ostream& lhs, Complex const& rhs)
{
return lhs << rhs.m_r << ‘+’ << rhs.m_i << ‘i’;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
std::cout << c1 << std::endl;

return 0;

}
上述代码中，以下代码：

std::ostream& operator<< (std::ostream& lhs, Complex const& rhs)
{
return lhs << rhs.m_r << ‘+’ << rhs.m_i << ‘i’;
}
定义了复数类Complex的<<输出流运算符的全局函数。因为左操作数的类型为ostream，若以成员函数形式重载该操作符，就应将其定义为ostream类的成员，该类为标准库提供，无法添加新的成员，因此只能以全局函数形式重载该操作符。非常第一参数以支持左值型左操作数，常第二参数以支持右值型右操作数，非常返回值以支持左值型表达式的值，返回引用型第一参数即左操作数本身。

上述代码中，以下代码：

friend std::ostream& operator<< (std::ostream&, Complex const&);

为了在一个全局操作符函数中直接访问其操作数类型的私有及保护成员，同时又不破坏其操作数类型的封装性，可以将该操作符函数声明为其操作数类型的友元。

6.3 完整代码
本案例的完整代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend std::ostream& operator<< (std::ostream&, Complex const&);
};
std::ostream& operator<< (std::ostream& lhs, Complex const& rhs)
{
return lhs << rhs.m_r << ‘+’ << rhs.m_i << ‘i’;
}
int main(int argc, const char * argv[])
{

Complex c1(3, 5);
std::cout << c1 << std::endl;

return 0;

}
7 支持>>操作符的复数类
7.1 问题
定义一个复数类，类中包括两个私有的成员变量，m_r代表实部，m_i代表虚部，并重载>>输入流运算符，以实现复数的输入操作。

7.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持>>操作符的复数类

使用递归方法，将数组先分成前后两部分，然后再将前一部分分解，最后将后一部分分解。

代码如下：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend std::istream& operator>> (std::istream&, Complex&);
friend std::ostream& operator<< (std::ostream&, Complex const&);
};
std::istream& operator>> (std::istream& lhs, Complex& rhs)
{
return lhs >> rhs.m_r >> rhs.m_i;
}
std::ostream& operator<< (std::ostream& lhs, Complex const& rhs)
{
return lhs << rhs.m_r << ‘+’ << rhs.m_i << ‘i’;
}
int main(int argc, const char * argv[])
{

Complex c1;
std::cin >> c1;
std::cout << c1 << std::endl;

return 0;

}
上述代码中，以下代码：

std::istream& operator>> (std::istream& lhs, Complex& rhs)
{
return lhs >> rhs.m_r >> rhs.m_i;
}
定义了复数类Complex的>>输入流运算符的全局函数。因为左操作数的类型为istream，若以成员函数形式重载该操作符，就应将其定义为istream类的成员，该类为标准库提供，无法添加新的成员，因此只能以全局函数形式重载该操作符。非常第一参数以支持左值型左操作数，非常第二参数以支持左值型右操作数，非常返回值以支持左值型表达式的值，返回引用型第一参数即左操作数本身。

上述代码中，以下代码：

friend std::istream& operator>> (std::istream&, Complex&);

为了在一个全局操作符函数中直接访问其操作数类型的私有及保护成员，同时又不破坏其操作数类型的封装性，可以将该操作符函数声明为其操作数类型的友元。

7.3 完整代码
本案例的完整代码如下所示：

#include
class Complex
{
private:
int m_r;//实部
int m_i;//虚部
public:
Complex (double r = 0, double i = 0) : m_r®, m_i(i)
{
}
void show (void) const
{
std::cout << m_r << “+” << m_i << “i” << std::endl;
}
friend std::istream& operator>> (std::istream&, Complex&);
friend std::ostream& operator<< (std::ostream&, Complex const&);
};
std::istream& operator>> (std::istream& lhs, Complex& rhs)
{
return lhs >> rhs.m_r >> rhs.m_i;
}
std::ostream& operator<< (std::ostream& lhs, Complex const& rhs)
{
return lhs << rhs.m_r << ‘+’ << rhs.m_i << ‘i’;
}
int main(int argc, const char * argv[])
{

Complex c1;
std::cin >> c1;
std::cout << c1 << std::endl;

return 0;

}
8 支持[]操作符的数组类
8.1 问题
下标[]操作符重载常用于在容器类型中以下标方式获取数据元素，对于非常容器的元素为左值，对于常容器的元素为右值。

8.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持[]操作符的数组类

代码如下：

#include
class Array
{
private:
int m_array[256];
public:
Array (void)
{
memset(m_array, 0, sizeof(m_array));
}
int& operator[] (size_t i)
{
return m_array[i];
}
const int& operator[] (size_t i) const
{
return const_cast<Array&> (*this)[i];
}
};
int main(int argc, const char * argv[])
{

Array array;
array[100] = 1000;
std::cout << array.operator[] (100) << std::endl;

const Array& carray = array;
std::cout << carray[100] << std::endl;

return 0;

}
上述代码中，以下代码：

int& operator[] (size_t i)
{
    return m_array[i];
}

定义了容器类Array的下标[]操作符重载。由于非常容器的元素可能为左值，如在主程序中的以下代码：

array[100] = 1000;

所以，下标[]操作符的重载函数的返回值必须是引用类型。

上述代码中，以下代码：

const int& operator[] (size_t i) const
{
    return const_cast<Array&> (*this)[i];
}

是由于常容器的元素只能作为右值，如在主程序中的以下代码：

const Array& carray = array;
std::cout << carray[100] << std::endl;

carray即为常容器对象，常容器的元素carray[100]因为是常量，所以只能做右值使用。

8.3 完整代码
本案例的完整代码如下所示：

#include
class Array
{
private:
int m_array[256];
public:
Array (void)
{
memset(m_array, 0, sizeof(m_array));
}
int& operator[] (size_t i)
{
return m_array[i];
}
const int& operator[] (size_t i) const
{
return const_cast<Array&> (*this)[i];
}
};
int main(int argc, const char * argv[])
{

Array array;
array[100] = 1000;
std::cout << array.operator[] (100) << std::endl;

const Array& carray = array;
std::cout << std::hex << &array << std::dec << std::endl;
std::cout << carray[100] << std::endl;

return 0;

}
9 支持()操作符的平方类
9.1 问题
如果一个类重载了函数操作符()，那么该类的对象就可以被当做函数来调用，其参数和返回值就是函数操作符函数的参数和返回值，参数的个数、类型以及返回值的类型，没有限制，函数操作符()是唯一可以带有缺省参数的操作符重载函数。

9.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持()操作符的平方类

代码如下：

#include
class Square
{
public:
int operator() (int x)
{
return x * x;
}
};
int main(int argc, const char * argv[])
{

Square square;
std::cout << square(5) << std::endl;

return 0;

}
上述代码中，以下代码：

int operator() (int x)
{
    return x * x;
}

定义了类Square的函数操作符()重载。当一个类重载了函数操作符()后，该类的对象就可以被当做函数来调用，如在主程序中的以下语句：

std::cout << square(5) << std::endl;

其中square是一个对象，不是函数名，但square(5)的使用方法与调用一个函数没有区别，就是因为重载了函数操作符的缘故。

9.3 完整代码
本案例的完整代码如下所示：

#include
class Square
{
public:
int operator() (int x)
{
return x * x;
}
};
int main(int argc, const char * argv[])
{

Square square;
std::cout << square(5) << std::endl;

return 0;

}
10 简化版的智能指针类
10.1 问题
如果一个类重载了解引用*操作符和间接成员访问->操作符，那么该类的对象就可以被当做指针来使用。智能指针是一个封装了常规指针的类类型对象，当它离开作用域时，其析构函数负责释放该常规指针所指向的动态内存。任何时候，针对同一个对象，只允许有一个智能指针持有其地址，否则该对象将在多个智能指针中被析构多次，因此智能指针的拷贝构造和拷贝赋值需要做特殊处理，对其所持有的对象地址，以指针间的转移代替复制。

10.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：简化版的智能指针类

代码如下：

#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val) : m_val(val)
{
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
};
class IntegerPointer
{
private:
Integer* m_p;
public:
IntegerPointer (Integer* p = NULL) : m_p§
{
}
IntegerPointer (IntegerPointer& p)
{
m_p = p.m_p;
p.m_p = NULL;
}
~IntegerPointer ()
{
delete m_p;
}
IntegerPointer& operator= (IntegerPointer& p)
{
if (&p != this)
{
delete m_p;
m_p = p.m_p;
p.m_p = NULL;
}
return this;
}
Integer& operator (void) const
{
return m_p;
}
Integer operator-> (void) const
{
return m_p;
}
};
int main(int argc, const char * argv[])
{

IntegerPointer ip(new Integer(100));
std::cout << (*ip).value() << std::endl;
ip->value()++;
std::cout << ip->value() << std::endl;

IntegerPointer ip1 = ip;
//std::cout << ip->value() << std::endl;
std::cout << ip1->value() << std::endl;

IntegerPointer ip2(new Integer(200));
ip2 = ip1;
//std::cout << ip1->value() << std::endl;
std::cout << ip2->value() << std::endl;

return 0;

}
上述代码中，以下代码：

class IntegerPointer
定义了一个简化版的智能指针类IntegerPointer。

上述代码中，以下代码：

Integer& operator* (void) const
{
    return *m_p;
}

在类IntegerPoiner中重载了解引用操作符，由于解引用操作符可以将指针指向的内存单元的内容取出来，所以该函数返回一个当前指针m_p指向的对象。如在主程序中的以下语句：

std::cout << (*ip).value() << std::endl;

等效于如下语句：

std::cout << (ip.operator*()).value() << std::endl;

其中(ip)，即(ip.operator())，得到的是智能指针ip指向的对象。

上述代码中，以下代码：

Integer* operator-> (void) const
{
    return m_p;
}

在类IntegerPoiner中重载了间接成员访问->操作符，使得主程序中的如下语句：

std::cout << ip->value() << std::endl;

使得智能指针ip可以访问其指向的对象的成员。

上述代码中，以下代码：

IntegerPointer (IntegerPointer& p)
{
    m_p = p.m_p;
    p.m_p = NULL;
}

重新定义了拷贝构造函数，这是因为在任何时候，针对同一个对象，只允许有一个智能指针持有其地址，否则该对象将在多个智能指针中被析构多次。如在主程序中的以下语句：

IntegerPointer ip1 = ip;

如果不按上述方法重新定义拷贝构造函数，则智能指针ip和ip1指向同一对象，当两个对象的作用域结束时，都要调用如下析构函数：

~IntegerPointer ()
{
    delete m_p;
}

释放其指向的存储空间，当ip和ip1指向的是同一个对象，释放两次，第二次必然会导致程序崩溃。

上述代码中，以下代码：

IntegerPointer& operator= (IntegerPointer& p)
{
    if (&p != this)
    {
        delete m_p;
        m_p = p.m_p;
        p.m_p = NULL;
    }
    return *this;
}

重载了赋值=操作符，也是为了防止多个智能指针指向同一个对象导致的被析构多次。如在主程序中的以下语句：

IntegerPointer ip2(new Integer(200));
ip2 = ip1;

当一个智能指针ip1赋值给另一个智能指针ip2时，ip1将变成空指针，以防止多个智能指针指向同一个对象。

10.3 完整代码
本案例的完整代码如下所示：

#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val) : m_val(val)
{
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
};
class IntegerPointer
{
private:
Integer* m_p;
public:
IntegerPointer (Integer* p = NULL) : m_p§
{
}
IntegerPointer (IntegerPointer& p)
{
m_p = p.m_p;
p.m_p = NULL;
}
~IntegerPointer ()
{
delete m_p;
}
IntegerPointer& operator= (IntegerPointer& p)
{
if (&p != this)
{
delete m_p;
m_p = p.m_p;
p.m_p = NULL;
}
return this;
}
Integer& operator (void) const
{
return m_p;
}
Integer operator-> (void) const
{
return m_p;
}
};
int main(int argc, const char * argv[])
{

IntegerPointer ip(new Integer(100));
std::cout << (*ip).value() << std::endl;
ip->value()++;
std::cout << ip->value() << std::endl;

IntegerPointer ip1 = ip;
//std::cout << ip->value() << std::endl;
std::cout << ip1->value() << std::endl;

IntegerPointer ip2(new Integer(200));
ip2 = ip1;
//std::cout << ip1->value() << std::endl;
std::cout << ip2->value() << std::endl;

return 0;

}
11 auto_ptr的基本用法和局限
11.1 问题
auto_ptr模板定义了类似指针的对象，可以将new直接或间接获得的地址赋值给这种对象。当auto_ptr对象生命周期结束时，其析构函数会将auto_ptr对象拥有的动态内存自动释放。即使发生异常，通过异常的栈展开过程也能将动态内存释放。

11.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：auto_ptr的基本用法和局限

代码如下：

#include
#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val) : m_val(val)
{
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
};
int main(int argc, const char * argv[])
{

std::auto_ptr<Integer> ip (new Integer(100));
std::cout << (*ip).value() << std::endl;
ip->value()++;
std::cout << ip->value() << std::endl;

std::auto_ptr<Integer> ip1 = ip;
//std::cout << ip->value() << std::endl;
std::cout << ip1->value() << std::endl;

std::auto_ptr<Integer> ip2(new Integer(200));
ip2 = ip1;
//std::cout << ip1->value() << std::endl;
std::cout << ip2->value() << std::endl;

//std::auto_ptr<Integer> ip3(new Integer[10]);

return 0;

}
上述代码中，以下代码：

std::auto_ptr<Integer> ip (new Integer(100));

定义了一个auto_ptr智能指针模板类的对象ip，指向一个由new生成的类Integer的对象，其中表示智能指针的数据类型。

上述代码中，以下代码：

std::cout << (*ip).value() << std::endl;

由于在模板类auto_ptr中重载了解引用*操作符，所以(*ip)即是上面用new生成的类Integer的对象。

上述代码中，以下代码：

std::cout << ip->value() << std::endl;

由于在模板类auto_ptr中重载了间接成员访问->操作符，所以模板类auto_ptr的对象ip可以访问到上面用new生成的类Integer的对象的成员函数。

上述代码中，以下代码：

std::auto_ptr<Integer> ip1 = ip;
//std::cout << ip->value() << std::endl;
std::cout << ip1->value() << std::endl;

由于在模板类auto_ptr中重新定义了拷贝构造函数，所以当将ip初始化给ip1时，ip将自动变成空指针，这是因为在任何时候，针对同一个对象，只允许有一个模板类auto_ptr指针持有其地址，否则该对象将在多个模板类auto_ptr指针中被析构多次，造成程序崩溃。

上述代码中，以下代码：

std::auto_ptr<Integer> ip2(new Integer(200));
ip2 = ip1;
//std::cout << ip1->value() << std::endl;
std::cout << ip2->value() << std::endl;

由于重载了模板类auto_ptr中赋值=操作符，所以当将ip1赋值给ip2时，ip1将自动变成空指针，这也是为了防止同一个对象在多个模板类auto_ptr指针中被析构多次。

上述代码中，以下代码：

//std::auto_ptr<Integer> ip3(new Integer[10]);

不允许让模板类auto_ptr指针指向对象数组。这是因为在模板类auto_ptr中的析构函数是使用delete释放存储空间的，而不是使用delete[]释放。

11.3 完整代码
本案例的完整代码如下所示：

#include
#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val) : m_val(val)
{
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
};
int main(int argc, const char * argv[])
{

std::auto_ptr<Integer> ip (new Integer(100));
std::cout << (*ip).value() << std::endl;
ip->value()++;
std::cout << ip->value() << std::endl;

std::auto_ptr<Integer> ip1 = ip;
//std::cout << ip->value() << std::endl;
std::cout << ip1->value() << std::endl;

std::auto_ptr<Integer> ip2(new Integer(200));
ip2 = ip1;
//std::cout << ip1->value() << std::endl;
std::cout << ip2->value() << std::endl;

//std::auto_ptr<Integer> ip3(new Integer[10]);

return 0;

}
12 在基本类型和类类型之间做类型转换
12.1 问题
由基本数据类型向类数据类型转换，只能通过类类型的构造函数实现。由类数据类型向基本数据类型转换，只能通过类类型的类型转换操作符函数实现。

12.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：在基本类型和类类型之间做类型转换

代码如下：

#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val) : m_val(val)
{
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
operator int (void) const
{
return m_val;
}
};
int main(int argc, const char * argv[])
{

Integer i = 10;
std::cout << i.value() << std::endl;

i = 20;
std::cout << i.value() << std::endl;

int a = i;
std::cout << a << std::endl;

return 0;

}
上述代码中，以下代码：

Integer (const int& val) : m_val(val)
{
}

是类Integer的构造函数，当此构造函数如上只有一个形参时，它还有一个功能就是由基本数据类型int向类数据类型Integer进行转换。如在主程序中，以下语句：

Integer i = 10;

和以下语句：

i = 20;

都是将int型数据赋值给类Integer类型的对象，我们知道，当赋值号两边的数据类型不一致时，会按照左值的类型进行转换。左值的类型为类Integer，所以转换方法就是类Integer的构造函数。

上述代码中，以下代码：

operator int (void) const
{
    return m_val;
}

是类Integer的类型转换操作符函数，该函数可以将类数据类型Integer的数据向基本数据类型int进行转换。如在主程序中，以下语句：

int a = i;

是将类Integer类型的对象赋值给int型变量，此时需要将类Integer类型转换成int类型，这个转换方法由类Integer的operator int (void) const函数完成。

注意：以上类型之间的转换都是隐式转换，可以使用关键字explicit加以禁止。

如将代码写成：

explicit Integer (const int& val) : m_val(val)
{
}

则主程序中的如下语句：

Integer i = 10;

和以下语句：

i = 20;

将变成非法。

12.3 完整代码
本案例的完整代码如下所示：

#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val) : m_val(val)
{
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
operator int (void) const
{
return m_val;
}
};
int main(int argc, const char * argv[])
{

Integer i = 10;
std::cout << i.value() << std::endl;

i = 20;
std::cout << i.value() << std::endl;

int a = i;
std::cout << a << std::endl;

return 0;

}
13 重载new和delete操作符
13.1 问题
由于new和delete都是运算符，所以可以重载new和delete。这样做的好处是，有时希望使用某种特殊的动态内存分配方法。例如，可能有些分配子程序，他们的堆已耗尽，自动开始把一个磁盘文件当虚存储使用，或者用户希望控制某一片存储空间的分配等。

13.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：重载new和delete操作符

代码如下：

#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val = 0) : m_val(val)
{
}
~Integer ()
{
std::cout << “Integer destructor” << std::endl;
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
static void* operator new (size_t size)
{
return malloc(size);
}
static void* operator new[] (size_t size)
{
return malloc(size);
}
static void operator delete (void* p)
{
free§;
}
static void operator delete[] (void* p)
{
free§;
}
};
int main(int argc, const char * argv[])
{

Integer *pi = new Integer(10);
std::cout << pi->value() << std::endl;

delete pi;

Integer *pi1 = new Integer[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
for (int i = 0; i < 10; i++)
    std::cout << pi1[i].value() << " ";
std::cout << std::endl;

delete[] pi1;

return 0;

}
上述代码中，以下代码：

static void* operator new (size_t size)
{
    return malloc(size);
}

类Integer重载了new操作符。那么当在主程序中，通过如下代码：

Integer *pi = new Integer(10);

使用new创建该类的对象，此时将首先调用该操作符函数分配内存，然后再调用该类的构造函数。

上述代码中，以下代码：

static void operator delete (void* p)
{
    free(p);
}

类Integer重载了delete操作符。那么当在主程序中，通过如下代码：

delete pi;

使用delete销毁该类的对象，此时将首先调用该类的析构函数，然后再调用该操作符函数释放内存。

上述代码中，以下代码：

static void* operator new[] (size_t size)
{
    return malloc(size);
}

类Integer重载了new[]操作符。那么当在主程序中，通过如下代码：

Integer *pi1 = new Integer[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

使用new[]创建该类的对象数组，此时将首先调用该操作符函数为数组的每个元素分配内存，然后再为数组的每个元素调用该类的构造函数。

上述代码中，以下代码：

static void operator delete[] (void* p)
{
    free(p);
}

类Integer重载了delete[]操作符。那么当在主程序中，通过如下代码：

delete[] pi1;

使用delete[]销毁该类的对象数组，此时将首先为数组的每个元素调用该类的析构函数，然后再为数组的每个元素调用该操作符函数释放内存

13.3 完整代码
本案例的完整代码如下所示：

#include
class Integer
{
private:
int m_val;
public:
Integer (const int& val = 0) : m_val(val)
{
}
~Integer ()
{
std::cout << “Integer destructor” << std::endl;
}
int& value (void)
{
return m_val;
}
const int& value (void) const
{
return m_val;
}
static void* operator new (size_t size)
{
return malloc(size);
}
static void* operator new[] (size_t size)
{
return malloc(size);
}
static void operator delete (void* p)
{
free§;
}
static void operator delete[] (void* p)
{
free§;
}
};
int main(int argc, const char * argv[])
{

Integer *pi = new Integer(10);
std::cout << pi->value() << std::endl;

delete pi;

Integer *pi1 = new Integer[10] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
for (int i = 0; i < 10; i++)
    std::cout << pi1[i].value() << " ";
std::cout << std::endl;

delete[] pi1;

return 0;

}

蒙宇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ linux 获取毫秒_Linux c++获取本地毫秒级精确时间
weixin_36162883的博客
01-26 2661
时间函数介绍Linux c/c++中提供了很多操作时间的库函数，这里简要介绍。使用头文件 #include常用的时间函数包括以下：time原型：time_t time(time_t *t);返回从公元1970年1月1日的UTC时间从0时0分0秒算起到现在所经过的秒数如果t 并非空指针的话，此函数也会将返回值存到t指针所指的内存成功则返回秒数，失败则返回((time_t)-1)值，错误原因存于err...
linux c++程序修改系统时间,Linux C++ 获取和设置系统时间
weixin_39585974的博客
05-01 1682
CSystemTime.h/** CSystemTime.h** Created on: 2014-3-12* Author: qinyinghao* 用于获取和设置系统时间*/#ifndef CSYSTEMTIME_H_#define CSYSTEMTIME_H_extern "C" {#include #include }namespace qyh {typedef struct {in...
C++Linux网络编程Day01
默示MoS的博客
01-25 1035
基本所有的知识点我都写在其中了，有些基础性的东西需要大家自己去学习”计算机网络“的相关知识，至于为什么在使用accept等函数的时候，需要将sockaddr_in转换成sockaddr，这点需要看书：游双的《Linux高性能服务器编程》，在其中的第五章第一节：socket地址API中有详细讨论。。
C++Linux网络编程day02：select模型
默示MoS的博客
02-09 1149
初步认识select模型和进一步认识socket
C++Linux编程基础
默示MoS的博客
01-20 996
C++的Linux网络编程基础知识点
Linux C/C++时间操作
qq_40135848的博客
06-02 643
Linux C/C++时间操作
C++linux高并发服务器项目实践 day1
mcyuuji的博客
03-15 310
实际上，这个宏只是标志着编译器将会吧代码按c还是c++语法来解释如上所述，如果后缀为.c，并且采用gcc编译器，则该宏就是未定义的，否则，就是已定义。
Linux C/C++ 获取系统时间
bluebird_shao的专栏
12-15 5635
C 标准库提供了time()函数与函数可以获取到当前系统的日历时间，但time()函数精度只能到秒级，如果需要更高精度的系统时间需要使用函数，精度达到微秒级。
C++ day5
最新发布
Johan1111的博客
06-11 89
思维导图：
C++ day7
m0_54896893的博客
03-19 251
思维导图：
c++day13
04-25
"C++day13"可能指的是学习C++的第13天，通常在这个阶段，学生会深入理解基础语法，开始接触更高级的概念。描述中的“zuoyezuoyezuoyezuoye”虽然看起来像是重复的练习，但它实际上强调了编程学习的核心——不断实践...
c++day14
04-26
在"C++ Day14"的学习中，我们深入探讨了C++这一强大且广泛使用的编程语言。C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也支持面向对象编程的程序设计语言。C++是在C语言的基础上...
mysql-data-clean-timer.zip_linux c++ 数据库_linux mysql_log mysql
09-14
标题“mysql-data-clean-timer.zip”暗示了一个C++编写的程序，用于在Linux环境中定时清理MySQL数据库中过期的日志数据。这个程序可能是为了解决日志文件占用过多磁盘空间的问题，确保系统运行效率和数据管理的有效...
C++基础入门.pdf
04-10
long（长整形）：Windows为4字节，Linux为4字节（32位），8字节（64位），取值范围为-2^31 ~ 2^31-1; long long（长长整形）：占用8字节，取值范围为-2^63 ~ 2^63-1; 本文档提供了C++基础知识的入门指南，包括创建...
安装Centos7.9&C++&转源到阿里云.doc
10-17
在Linux中，C/C++的开发通常需要安装一些基础工具和库。使用`yum`命令依次安装make、gcc-c++、cmake、bison-devel、ncurses-devel、libaio及其开发库。另外，还需要安装perl-Data-Dumper和net-tools。之后，使用`yum...
QT面试
qq_40632341的博客
01-11 2750
1.事件循环 Qt的主事件循环能够从事件队列中获取本地窗口系统事件，然后判断事件类型，并将事件分发给特定的接收对象。 主事件循环通过调用QCoreApplication::exec()启动，随着QCoreApplication::exit()结束，本地的事件循环可用利用QEventLoop构建。 2.多线程 继承QThread方法 1.定义继承QThread的类A 重写run()函数; 2.在主线...
linux C++ day1
qq_40632341的博客
02-10 273
linux C++ day1 编译器 -g++ -gcc -lstdc++ 扩展名 -.cpp/.cc/.C/.cxx -.c -x C++ 头文件 –#include -#include I/O流 –cout<< –cin>> –也可以用scanf/printf 名字空间 –std:: –using namespace std; –所有标准类型、对象和函数都位于std命名...
Linux C++ day2
qq_40632341的博客
02-11 193
重载与缺省参数==》重载{重载与重载缺省 C++换名 extern"C"}缺省参数 重载与重载解析 同一作用域中，函数名相同，参数表不同的函数，构成重载关系 –void foo(void); void foo(int n); void foo(int* p); char const* foo(int n,double d); char const* foo(double d,int n); 重载与...
linux C++ day06
qq_40632341的博客
02-13 171
目录： 支持结息调息功能的银行账户类 饿汉式的单例模式 懒汉式的单例模式 考虑线程安全的单例模式 通过成员指针访问对象 1 支持结息调息功能的银行账户类 1.1 问题 静态成员变量不包含在对象实例中，具有进程级的生命周期。静态成员函数没有this指针，也没有常属性。但是静态成员受类作用域和访问控制限定符的约束。静态成员变量的声明在类中；而定义和初始化，只能在类的外部而不能在构造函数中进行。静态成员...
linux c++ std::atomic
08-15
引用中提供了三个std::atomic_flag的成员函数，分别是test_and_set、clear和exchange。test_and_set函数用于设置atomic_flag并返回之前的状态，clear函数用于清除atomic_flag的状态，exchange函数用于替换atomic_flag的值并返回之前的值。这些函数可以用来实现自旋锁。引用中还提供了一个std::atomic的成员函数exchange，用于替换atomic的值并返回之前的值。引用中给出了std::atomic的store、load、operator和exchange等成员函数的用法和示例。因此，在linux c中，可以使用std::atomic来实现原子操作。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [linux c/c++ 原子操作库 atomic atomic_flag 简介](https://blog.csdn.net/whatday/article/details/122298078)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值