C++模板类的符号重载,C\C++交流,技术交流,鱼C论坛

bin554385863 发表于 2019-11-19 22:42:15

C++模板类的符号重载

本帖最后由 bin554385863 于 2019-11-19 22:56 编辑

这是我对照C++string写的一个数字串的类
重载的加号是用来拼接的,不知道为啥会出现数字溢出,

numbers.h
#ifndef NUMBERS_H
#define NUMBERS_H
#include <iostream>
#include <initializer_list>
template <typename tp>
class numbers
{
private:
tp *NUM;
size_t LENGTH;
public:

numbers(const tp *carray, size_t sz);//数组构造

numbers() : LENGTH(0), NUM(nullptr) {} //默认构造*****

numbers(std::initializer_list<tp> list); //普通构造*****

numbers(numbers<tp> &arr); //复制构造*****

void pushback(const tp data); //尾部插入元素*****

size_t size(); //数字串的大小*****

tp &operator[](const size_t i); //重载索引下标符号[]*****

size_t find(tp num); //在对象中查找一个元素,返回索引*****

bool find(numbers<tp> &nums); //在对象中查找另一个对象,返回bool值*****

numbers<tp> operator+(numbers<tp>& nums);//拼接

numbers<tp> operator-(numbers<tp>& nums);//删除于第二个对象相同的元素

numbers<tp> operator-(tp num);//删除与num相同的元素

friend std::ostream &operator<<(std::ostream &os, numbers<tp> &arr)
//重载输出流符号<<
{
   for (size_t i = 0; i < arr.size(); i++)
   {
         os << arr;
   }
   return os;
}
//析构函数
~numbers();
};
#endif
numbers.cpp
#include "numbers.h"
template <typename tp>
numbers<tp>::numbers(const tp *carray, size_t sz) : LENGTH(sz) //数组构造
{
NUM = new tp{0};
for (size_t i = 0; i < LENGTH; i++)
{
   *(NUM + i) = carray;
}
}
template <typename tp>
numbers<tp>::numbers(std::initializer_list<tp> list) : LENGTH(list.size())
//普通构造
{
NUM = new tp;
for (size_t i = 0; i < LENGTH; i++)
{
   NUM = *(list.begin() + i);
}
}
template <typename tp>
numbers<tp>::numbers(numbers<tp> &arr) //复制构造
{
LENGTH = arr.LENGTH;
NUM = new tp;
for (size_t i = 0; i < LENGTH; i++)
{
   *(NUM + i) = arr;
}
}
template <typename tp>
void numbers<tp>::pushback(const tp data) //尾部插入元素
{
tp *t_NUM = new tp;
for (size_t i = 0; i < LENGTH; i++)
{
   t_NUM = NUM;
}
t_NUM = data;
LENGTH += 1;
delete[] NUM;
NUM = t_NUM;
}
template <typename tp>
size_t numbers<tp>::size() //取得对象的大小
{
return LENGTH;
}
template <typename tp>
tp &numbers<tp>::operator[](const size_t i) //重载索引符[]
{
return NUM;
}
template <typename tp>
size_t numbers<tp>::find(const tp num) //在对象里查找元素num是否存在
//如果存在则返回出现的次数,否则返回0
{
size_t count = 0;
for (size_t i = 0; i < LENGTH; i++)
{
   if (num == NUM)
   {
         count++;
   }
}
return count;
}
template <typename tp>
bool numbers<tp>::find(numbers<tp> &nums) //查找子对象的元素是否存在于父对象中
{
bool flag = true;
if (nums.LENGTH > LENGTH)
{
   flag = false;
}
else
{
   unsigned int count = 1;
   for (size_t i = 0; i < nums.LENGTH; i++)
   {
         if (this->find(nums.NUM))
         {
            count++;
         }
         else
         {
            flag = false;
            break;
         }
   }
   if (count == nums.LENGTH)
   {
         flag = true;
   }
}
return flag;
}
template <typename tp>
numbers<tp> numbers<tp>::operator+(numbers<tp>& nums)
{
numbers<tp> result(NUM, LENGTH);
for (size_t i = 0; i < nums.size(); i++)
{
   result.pushback(nums);
}
std::cout<<result;
return result;//在这里已经拼接成功
}
template <typename tp>
numbers<tp>::~numbers() //析构函数
{
delete[] NUM;
}
int main(int argc, char const *argv[])
{
int arr = {1, 2, 3, 4};
numbers<int> nums(arr, 4);
numbers<int> a = {5, 6, 7};
numbers<int> b;
b = a+nums;
std::cout<<b;//这里输出乱码
return 0;
}

人造人 发表于 2019-11-19 23:27:43

#ifndef NUMBERS_H
#define NUMBERS_H

#include <iostream>
#include <initializer_list>

template <typename tp>
class numbers
{
private:
tp *NUM;
size_t LENGTH;
public:

numbers(const tp *carray, size_t sz);//数组构造

numbers(): LENGTH(0), NUM(nullptr) {} //默认构造*****

numbers(std::initializer_list<tp> list); //普通构造*****

numbers(numbers<tp> &arr); //复制构造*****

void pushback(const tp data); //尾部插入元素*****

size_t size(); //数字串的大小*****

tp &operator[](const size_t i); //重载索引下标符号[]*****

size_t find(tp num); //在对象中查找一个元素,返回索引*****

bool find(numbers<tp> &nums); //在对象中查找另一个对象,返回bool值*****

numbers<tp> operator+(numbers<tp>& nums);//拼接

numbers<tp> operator-(numbers<tp>& nums);//删除于第二个对象相同的元素

numbers<tp> operator-(tp num);//删除与num相同的元素

// 少了这个函数了
const numbers<tp> &operator=(const numbers<tp> &rhs)
{
delete this->NUM;
this->NUM = new tp;
this->LENGTH = rhs.LENGTH;
for(size_t i = 0; i < rhs.LENGTH; ++i)
this->NUM = rhs.NUM;
return *this;
}

friend std::ostream &operator<<(std::ostream &os, numbers<tp> &arr)
//重载输出流符号<<
{
for(size_t i = 0; i < arr.size(); i++)
{
os << arr;
}
return os;
}
//析构函数
~numbers();
};
#endif

template <typename tp>
numbers<tp>::numbers(const tp *carray, size_t sz): LENGTH(sz) //数组构造
{
NUM = new tp{0};
for(size_t i = 0; i < LENGTH; i++)
{
*(NUM + i) = carray;
}
}
template <typename tp>
numbers<tp>::numbers(std::initializer_list<tp> list): LENGTH(list.size())
//普通构造
{
NUM = new tp;
for(size_t i = 0; i < LENGTH; i++)
{
NUM = *(list.begin() + i);
}
}
template <typename tp>
numbers<tp>::numbers(numbers<tp> &arr) //复制构造
{
LENGTH = arr.LENGTH;
NUM = new tp;
for(size_t i = 0; i < LENGTH; i++)
{
*(NUM + i) = arr;
}
}
template <typename tp>
void numbers<tp>::pushback(const tp data) //尾部插入元素
{
tp *t_NUM = new tp;
for(size_t i = 0; i < LENGTH; i++)
{
t_NUM = NUM;
}
t_NUM = data;
LENGTH += 1;
delete[] NUM;
NUM = t_NUM;
}
template <typename tp>
size_t numbers<tp>::size() //取得对象的大小
{
return LENGTH;
}
template <typename tp>
tp &numbers<tp>::operator[](const size_t i) //重载索引符[]
{
return NUM;
}
template <typename tp>
size_t numbers<tp>::find(const tp num) //在对象里查找元素num是否存在
//如果存在则返回出现的次数,否则返回0
{
size_t count = 0;
for(size_t i = 0; i < LENGTH; i++)
{
if(num == NUM)
{
count++;
}
}
return count;
}
template <typename tp>
bool numbers<tp>::find(numbers<tp> &nums) //查找子对象的元素是否存在于父对象中
{
bool flag = true;
if(nums.LENGTH > LENGTH)
{
flag = false;
}
else
{
unsigned int count = 1;
for(size_t i = 0; i < nums.LENGTH; i++)
{
if(this->find(nums.NUM))
{
count++;
}
else
{
flag = false;
break;
}
}
if(count == nums.LENGTH)
{
flag = true;
}
}
return flag;
}
template <typename tp>
numbers<tp> numbers<tp>::operator+(numbers<tp>& nums)
{
numbers<tp> result(NUM, LENGTH);
for(size_t i = 0; i < nums.size(); i++)
{
result.pushback(nums);
}
//std::cout << result;
return result;//在这里已经拼接成功
}
template <typename tp>
numbers<tp>::~numbers() //析构函数
{
delete[] NUM;
}
int main(int argc, char const *argv[])
{
int arr = {1, 2, 3, 4};
numbers<int> nums(arr, 4);
numbers<int> a = {5, 6, 7};
numbers<int> b;
b = a + nums;
std::cout << b;//现在正常了
return 0;
}

bin554385863 发表于 2019-11-19 23:31:49

人造人发表于 2019-11-19 23:27

{:10_285:}
我以为有个复制构造函数就不用了重载等号了

人造人 发表于 2019-11-19 23:34:46

bin554385863 发表于 2019-11-19 23:31
我以为有个复制构造函数就不用了重载等号了

你不写，编译器的确会为你写一个，但是编译器为你写的这个版本是进行浅拷贝，在这里必须进行深拷贝
所以这里不能用编译器的默认版本，你必须提供你自己的版本

bin554385863 发表于 2019-11-19 23:36:56

人造人发表于 2019-11-19 23:34
你不写，编译器的确会为你写一个，但是编译器为你写的这个版本是进行浅拷贝，在这里必须进行深拷贝
所以 ...

原来这样,就这个问题折腾了我俩小时{:10_285:}

人造人 发表于 2019-11-19 23:37:50

bin554385863 发表于 2019-11-19 23:36
原来这样,就这个问题折腾了我俩小时

^_^

bin554385863 发表于 2019-11-19 23:41:25

人造人发表于 2019-11-19 23:37
^_^

谢谢了,不懂得再问你哈,貌似论坛里C++不怎么多啊{:10_266:}

人造人 发表于 2019-11-19 23:44:19

bin554385863 发表于 2019-11-19 23:41
谢谢了,不懂得再问你哈,貌似论坛里C++不怎么多啊

嗯，的确不多了，都去python版块了
^_^

bin554385863 发表于 2019-11-19 23:48:24

人造人发表于 2019-11-19 23:44
嗯，的确不多了，都去python版块了
^_^

Python么,算了没兴趣,我自己的计划是C---C++----C#
不过我感觉C++的坑太难爬了{:10_247:}

人造人 发表于 2019-11-19 23:52:07

bin554385863 发表于 2019-11-19 23:48
Python么,算了没兴趣,我自己的计划是C---C++----C#
不过我感觉C++的坑太难爬了

我也不喜欢python

“不过我感觉C++的坑太难爬了”
还行吧，推荐一本书《C++ Primer Plus （第6版）中文版》
这本书真的不错

bin554385863 发表于 2019-11-19 23:58:59

本帖最后由 bin554385863 于 2019-11-20 00:01 编辑

人造人发表于 2019-11-19 23:52
我也不喜欢python

我有
还有侯捷的effective C++
plus 学了一半了,不过我本来只想写个简简单单的类练习一下,没想到写到模板类上面去了,我现在都是一边翻书一边写.不然都写不下去(╯‵□′)╯︵┻━┻
还有迭代器目前实在搞不定

人造人 发表于 2019-11-20 01:29:31

bin554385863 发表于 2019-11-19 23:58
我有
还有侯捷的effective C++
plus 学了一半了,不过我本来只想写个简简单单的类练习一下,没想到写到 ...

不用着急，慢慢来吧
这玩意急也没用

页: [1]

鱼C论坛's Archiver

C++模板类的符号重载