设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 技术交流 › C\C++交流 › C++ number.h更新
返回列表 发新帖
查看: 1210|回复: 1

[技术交流] C++ number.h更新

[复制链接]
bin554385863
发表于 2019-11-24 22:23:32 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
本帖最后由 bin554385863 于 2019-11-24 22:51 编辑 
构造函数:
//默认构造
numbers():numsLen(0), numsPtr(nullptr){}
//使用C风格数字数组构造
numbers(const tp *arr, const size_t arrSize);
//字符数组构造
numbers(const char *ncstr)------2019年11月24日22:35:17增加
//可变参数构造
numbers(std::initializer_list<tp> list);
//拷贝构造
numbers(const numbers<tp>& nums);
注意:使用时请按规范输入数字或者数字字符数组,不然出现数据错误;
"-566666"---正确;
"*55555"---错误;*号会转化成错误数据;
除了-号请不要再数字字符前添加任何字符包括+号;

****************************************************
成员函数

at()(为了方便this指针使用,普通对象请使用索引符[]):
按索引获取数字串的元素;
按索引修改元素的值;

size():
获取对象的大小
****************************************************
重载运算符

[](改)
安索引修改对象元素的值;

+(增):
添加元素;
合并对象;

-(删)
删除对象中指定的数据;
删除父对象中与子对象相同的数据;
按索引删除元素参数必须显示声明为size_t类型
对象翻转数据的正负属性;------2019年11月24日22:35:32增加

%(查)
判断对象是否包含某数据;
判断子对象是否父对象的子串;

/(查):
返回数据在对象中出现的次数;
返回对象与对象相同的元素;

赋值运算符:

+= 
/=
-=
右边必须是可改变的对象;
1---增加数字字符数组构造函数:
    numbers(const char* ncstr);
template <typename tp>
numbers<tp>::numbers(const char *ncstr)
{
    std::string tstr = ncstr;
    if (ncstr[0] == '-')
    {
        numsLen = tstr.size() - 1;
        numsPtr = new tp[numsLen];
        tstr.erase(0, 1);
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = tstr[i] - '0';
        }
    }
    if(ncstr[0] != '-')
    {
        numsLen = tstr.size();
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = tstr[i] - '0';
        }
    }
}


2---增加翻转对象数据正负符号重载:
    numbers<tp> operator-(void) const;
template <typename tp>
numbers<tp> numbers<tp>::operator-(void) const
{
    numbers<tp> r_nums;
    for (size_t i = 0; i < numsLen; i++)
    {
        r_nums += -*(numsPtr + i);
    }
    return r_nums;
}
完整代码
numbers.h
#ifndef NUMBERS_H
#define NUMBERS_H
#include <iostream>
#include <initializer_list>
#include <string>
template <typename tp>
class numbers
{
private:
    size_t numsLen;
    tp *numsPtr;
public:
    //1--默认构造
    numbers() : numsLen(0), numsPtr(nullptr) {}
    //2--使用C风格数字数组构造
    numbers(const tp *arr, const size_t arrSize);
    //2*--char数字字符串构造
    numbers(const char* ncstr);
    //3--可变参数构造
    numbers(std::initializer_list<tp> list);
    //4--拷贝构造
    numbers(const numbers<tp> &nums);
    /*--------------------------------------------------------*/
    //5--按索引获取元素;按索引修改元素的值
    tp &at(const size_t index) const;
    //6--对象的大小
    size_t const size() const;
    /*--------------------------------------------------------*/
    //7--重载下标运算符
    tp &operator[](const size_t index) const;
    //8--深度拷贝
    numbers<tp> &operator=(const numbers<tp> &nums);
    //9--重载流运算符<<
    friend std::ostream &operator<<(std::ostream &os, const numbers<tp> &nums)
    {
        size_t sz = nums.size();
        for (size_t i = 0; i < sz; i++)
        {
            os << nums[i];
        }
        return os;
    }
    /*--------------------------------------------------------*/
    //10--添加元素
    numbers<tp> operator+(const tp num) const;
    numbers<tp>& operator+=(const tp num)
    {
        *this = *this + num; 
        return *this;
    }
    //11--合并对象
    numbers<tp> operator+(const numbers<tp> &nums) const;
    numbers<tp>& operator+=(const numbers<tp> &nums)
    {
        *this = *this + nums; 
        return *this;
    }
    /*--------------------------------------------------------*/
    //12--判断数据在对象中存在
    bool operator%(const tp num) const;
    //13--判断子对象是否父对象的子串
    bool operator%(const numbers<tp>& nums) const;
    /*--------------------------------------------------------*/
    //14--返回数据出现的次数
    size_t operator/(tp num) const;
    //15--返回两个对象共同的元素
    numbers<tp> operator/(const numbers<tp> &nums) const;
    //15-1返回并赋值
    numbers<tp> operator/=(const numbers<tp> &nums)
    {
        *this = *this / nums;
        return *this;
    }
    /*--------------------------------------------------------*/
    //16--删除元素
    numbers<tp> operator-(const tp num) const;
    numbers<tp> operator-=(const tp num)
    {
        *this = *this - num;
        return *this;
    }
    //17--删除父对象中与子对象中重复的元素
    numbers<tp> operator-(const numbers<tp> &nums) const;
    numbers<tp> operator-=(const numbers<tp> &nums)
    {
        *this = *this - nums;
        return *this;
    }
    //18--按索引删除元素(数据必须显示声明size_t类型)失败返回空串
    numbers<tp> operator-(const size_t index) const;
    numbers<tp> operator-=(const size_t index)
    {
        *this = *this - this->at(index);
        return *this;
    }
    //19-翻转数据的正负
    numbers<tp> operator-(void) const;
    /*--------------------------------------------------------*/
    ~numbers()
    {
        delete[] numsPtr;
    }
};
//2--使用C风格数字数组构造
template <typename tp>
numbers<tp>::numbers(const tp *arr, const size_t arrSize) : numsLen(arrSize)
{
    numsPtr = new tp[numsLen];
    for (size_t i = 0; i < numsLen; i++)
    {
        *(numsPtr + i) = *(arr + i);
    }
}
//char字符串构造
template <typename tp>
numbers<tp>::numbers(const char *ncstr)
{
    std::string tstr = ncstr;
    if (ncstr[0] == '-')
    {
        numsLen = tstr.size() - 1;
        numsPtr = new tp[numsLen];
        tstr.erase(0, 1);
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = tstr[i] - '0';
        }
    }
    if(ncstr[0] != '-')
    {
        numsLen = tstr.size();
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = tstr[i] - '0';
        }
    }
}
//3--可变参数构造
template <typename tp>
numbers<tp>::numbers(std::initializer_list<tp> list) : numsLen(list.size())
{
    numsPtr = new tp[numsLen];
    for (size_t i = 0; i < numsLen; i++)
    {
        *(numsPtr + i) = *(list.begin() + i);
    }
}
//4--拷贝构造
template <typename tp>
numbers<tp>::numbers(const numbers<tp> &nums)
{
    if (nums.numsPtr != nullptr)
    {
        numsLen = nums.numsLen;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = *(nums.numsPtr + i);
        }
    }
    else
    {
        numsLen = 0;
        numsPtr = nullptr;
    }
    
}
/*--------------------------------------------------------------------*/
//5--按索引获取元素;按索引修改元素的值
template <typename tp>
inline tp &numbers<tp>::at(const size_t index) const
{
    return numsPtr[index];
}
//6--对象的大小
template <typename tp>
inline const size_t numbers<tp>::size() const
{
    return numsLen;
}
/*--------------------------------------------------------*/
//7--重载下标运算符
template <typename tp>
inline tp &numbers<tp>::operator[](const size_t index) const
{
    return numsPtr[index];
}
/*--------------------------------------------------------*/
//8--深度拷贝
template <typename tp>
numbers<tp> &numbers<tp>::operator=(const numbers<tp> &nums)
{
    if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))//非空串的深度拷贝
    {
        numsLen = nums.numsLen;
        delete[] numsPtr;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = *(nums.numsPtr + i);
        }
    }
    if((numsPtr == nullptr)&&(nums.numsPtr != nullptr))//调用对象为空,操作对象非空
    {
        numsLen = nums.numsLen;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            this->at(i) = *(nums.numsPtr + i);
        }
    }
    if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))//调用对象非空,操作对象为空
    {
        numsLen = 0;
        delete [] numsPtr;
        numsPtr = nullptr;
    }
    
    return *this;
}
/*--------------------------------------------------------*/
//10--添加元素
template <typename tp>
numbers<tp> numbers<tp>::operator+(const tp num) const
{
    numbers<tp> r_nums;
    if (numsPtr != nullptr)
    {
        r_nums = *this;
        tp *t_numsPtr = new tp[numsLen + 1];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(t_numsPtr + i) = this->at(i);
        }
        *(t_numsPtr + numsLen) = num;
        r_nums.numsLen++;
        delete[] r_nums.numsPtr;
        r_nums.numsPtr = t_numsPtr;
    }
    else
    {
        r_nums.numsLen = 1 + numsLen;
        r_nums.numsPtr = new tp[numsLen + 1]{num};
    }

    return r_nums;
}
//11--合并对象
template <typename tp>
numbers<tp> numbers<tp>::operator+(const numbers<tp> &nums) const
{
    numbers<tp> t_nums;
    if (numsPtr != nullptr)
    {
        t_nums = *this;
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            t_nums = t_nums + *(nums.numsPtr + i);
        }
    }
    else
    {
        t_nums = nums;
    }

    return t_nums;
}
/*--------------------------------------------------------*/
//12--判断数据在对象中是否存在
template <typename tp>
bool numbers<tp>::operator%(const tp num) const
{
    bool flag = false;
    if (numsPtr != nullptr)
    {
        for (size_t i = 0; i < numsLen; i++)
        {
            if (num == *(numsPtr + i))
            {
                flag = true;
                break;
            }
        }
    }
    return flag;
}
//13--判断子对象是否父对象的子串
template <typename tp>
bool numbers<tp>::operator%(const numbers<tp> &nums) const
{
    bool flag = false;
    size_t count = 1;
    if (numsLen > nums.numsLen)
    {
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            if ((*this) % (*(nums.numsPtr + i)))
            {
                count++;
                if (count == nums.numsLen)
                {
                    break;
                }
            }
        }
        if (count == nums.numsLen)
        {
            flag = true;
        }
    }
    if (nums.numsPtr == 0)
    {
        flag = true;
    }
    return flag;
}
/*--------------------------------------------------------*/
//14--返回数据出现的次数
template <typename tp>
size_t numbers<tp>::operator/(tp num) const
{
    size_t count = 0;
    if (numsPtr != nullptr)
    {
        for (size_t i = 0; i < numsLen; i++)
        {
            if (this->at(i) == num)
            {
                count++;
            }
        }
    }
    return count;
}
//15--返回两个对象共同的元素
template <typename tp>
numbers<tp> numbers<tp>::operator/(const numbers<tp> &nums) const
{
    numbers<tp> r_nums;
    if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
    {
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            if ((*this)% (*(nums.numsPtr + i)))
            {
                r_nums += (*(nums.numsPtr + i));
            }
        }
    }
    return r_nums;
}
/*--------------------------------------------------------*/
//16--删除对象中符合条件的元素
template <typename tp>
numbers<tp> numbers<tp>::operator-(const tp num) const
{
    numbers<tp> r_nums;
    if (numsPtr != nullptr)
    {
        for (size_t i = 0; i < numsLen; i++)
        {
            if (this->at(i) != num)
            {
                r_nums += *(numsPtr + i);
            }
        }
    }
    return r_nums;
}
//17--删除父对象中与子对象中重复的元素
template <typename tp>
numbers<tp> numbers<tp>::operator-(const numbers<tp>& nums) const
{
    numbers<tp> r_nums;
    size_t count = 0;
    if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
    /*两个非空数字串*/
    {
        r_nums = *this;
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            if ((*this)%(*(nums.numsPtr + i)))
            {
                r_nums = r_nums - *(nums.numsPtr + i);    
            }     
        }
        if (r_nums.numsLen == 0)
        {
            delete [] r_nums.numsPtr;
            r_nums.numsPtr = nullptr;
        }
    }
    else if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))
    /*子串为空*/
    {
        r_nums = *this;
    }
    return r_nums;
}
//18--按索引删除元素(数据必须是size_t类型)失败返回空串
template <typename tp>
numbers<tp> numbers<tp>::operator-(const size_t index) const
{
    numbers<tp> r_nums;
    if ((index < numsLen ) && (numsPtr != nullptr))
    {
        for (size_t i = 0; i < index; i++)
        {
            r_nums = r_nums + *(numsPtr + i);
        }
        for (size_t i = index + 1; i < numsLen; i++)
        {
            r_nums = r_nums + *(numsPtr + i);
        }
    }
    return r_nums;
}
//19-翻转数据的正负
template <typename tp>
numbers<tp> numbers<tp>::operator-(void) const
{
    numbers<tp> r_nums;
    for (size_t i = 0; i < numsLen; i++)
    {
        r_nums += -*(numsPtr + i);
    }
    return r_nums;
}
#endif
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复

使用道具 举报

bin554385863
 楼主| 发表于 2019-11-24 23:38:30 | 显示全部楼层
本帖最后由 bin554385863 于 2019-11-25 02:12 编辑

2019年11月24日23:36:39
-----增加私有函数
void isnumbers(std::string& str);
//判断是否是数字字符串
template <typename tp>
void numbers<tp>::isnumbers(const std::string &str)
{
    size_t s = str.size();
    bool flag = true;
    if (str[0] != '-' && (!isdigit(str[0])))
    {
        flag = false;
    }
    if (str[0] == '-' || (isdigit(str[0])))
    {
        for (size_t i = 1; i < s; i++)
        {
            if(!isdigit(str[i]))
            {
                flag = false;
                std::cerr<<"Cannot convert to a valid number!"<<std::endl;
                exit(1);
            }
        }
        
    }
}
numbers.h
#ifndef NUMBERS_H
#define NUMBERS_H
#include <iostream>
#include <initializer_list>
#include <string>
#include <cctype>
template <typename tp>
class numbers
{
private:
    size_t numsLen;
    tp *numsPtr;
    void isnumbers(const std::string& str);
public:
    //1--默认构造
    numbers() : numsLen(0), numsPtr(nullptr) {}
    //2--使用C风格数字数组构造
    numbers(const tp *arr, const size_t arrSize);
    //2*--char数字字符串构造
    numbers(const char* ncstr);
    //3--可变参数构造
    numbers(std::initializer_list<tp> list);
    //4--拷贝构造
    numbers(const numbers<tp> &nums);
    /*--------------------------------------------------------*/
    //5--按索引获取元素;按索引修改元素的值
    tp &at(const size_t index) const;
    //6--对象的大小
    size_t const size() const;
    /*--------------------------------------------------------*/
    //7--重载下标运算符
    tp &operator[](const size_t index) const;
    //8--深度拷贝
    numbers<tp> &operator=(const numbers<tp> &nums);
    //9--重载流运算符<<
    friend std::ostream &operator<<(std::ostream &os, const numbers<tp> &nums)
    {
        size_t sz = nums.size();
        for (size_t i = 0; i < sz; i++)
        {
            os << nums[i];
        }
        return os;
    }
    /*--------------------------------------------------------*/
    //10--添加元素
    numbers<tp> operator+(const tp num) const;
    numbers<tp>& operator+=(const tp num)
    {
        *this = *this + num; 
        return *this;
    }
    //11--合并对象
    numbers<tp> operator+(const numbers<tp> &nums) const;
    numbers<tp>& operator+=(const numbers<tp> &nums)
    {
        *this = *this + nums; 
        return *this;
    }
    /*--------------------------------------------------------*/
    //12--判断数据在对象中存在
    bool operator%(const tp num) const;
    //13--判断子对象是否父对象的子串
    bool operator%(const numbers<tp>& nums) const;
    /*--------------------------------------------------------*/
    //14--返回数据出现的次数
    size_t operator/(tp num) const;
    //15--返回两个对象共同的元素
    numbers<tp> operator/(const numbers<tp> &nums) const;
    //15-1返回并赋值
    numbers<tp> operator/=(const numbers<tp> &nums)
    {
        *this = *this / nums;
        return *this;
    }
    /*--------------------------------------------------------*/
    //16--删除元素
    numbers<tp> operator-(const tp num) const;
    numbers<tp> operator-=(const tp num)
    {
        *this = *this - num;
        return *this;
    }
    //17--删除父对象中与子对象中重复的元素
    numbers<tp> operator-(const numbers<tp> &nums) const;
    numbers<tp> operator-=(const numbers<tp> &nums)
    {
        *this = *this - nums;
        return *this;
    }
    //18--按索引删除元素(数据必须显示声明size_t类型)失败返回空串
    numbers<tp> operator-(const size_t index) const;
    numbers<tp> operator-=(const size_t index)
    {
        *this = *this - this->at(index);
        return *this;
    }
    //19-翻转数据的正负
    numbers<tp> operator-(void) const;
    /*--------------------------------------------------------*/
    ~numbers()
    {
        delete[] numsPtr;
    }
};

//判断是否是数字字符串
template <typename tp>
void numbers<tp>::isnumbers(const std::string &str)
{
    size_t s = str.size();
    bool flag = true;
    if (str[0] != '-' && (!isdigit(str[0])))
    {
        flag = false;
    }
    if (str[0] == '-' || (isdigit(str[0])))
    {
        for (size_t i = 1; i < s; i++)
        {
            if(!isdigit(str[i]))
            {
                flag = false;
                std::cerr<<"Cannot convert to a valid number!"<<std::endl;
                exit(1);
            }
        }
        
    }
}
//2--使用C风格数字数组构造
template <typename tp>
numbers<tp>::numbers(const tp *arr, const size_t arrSize) : numsLen(arrSize)
{
    numsPtr = new tp[numsLen];
    for (size_t i = 0; i < numsLen; i++)
    {
        *(numsPtr + i) = *(arr + i);
    }
}
//char字符串构造
template <typename tp>
numbers<tp>::numbers(const char *ncstr)
{
    std::string tstr = ncstr;
    isnumbers(tstr);
    if (tstr[0] == '-')
    {
        size_t s = tstr.size();
        numsLen = tstr.size() - 1;
        numsPtr = new tp[numsLen];
        tstr.erase(0, 1);
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = '0' - tstr[i];
        }
    }
    else if (isdigit(tstr[0]))
    {
        numsLen = tstr.size();
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = tstr[i] - '0';
        }
    }
}
//3--可变参数构造
template <typename tp>
numbers<tp>::numbers(std::initializer_list<tp> list) : numsLen(list.size())
{
    numsPtr = new tp[numsLen];
    for (size_t i = 0; i < numsLen; i++)
    {
        *(numsPtr + i) = *(list.begin() + i);
    }
}
//4--拷贝构造
template <typename tp>
numbers<tp>::numbers(const numbers<tp> &nums)
{
    if (nums.numsPtr != nullptr)
    {
        numsLen = nums.numsLen;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = *(nums.numsPtr + i);
        }
    }
    else
    {
        numsLen = 0;
        numsPtr = nullptr;
    }
    
}
/*--------------------------------------------------------------------*/
//5--按索引获取元素;按索引修改元素的值
template <typename tp>
inline tp &numbers<tp>::at(const size_t index) const
{
    return numsPtr[index];
}
//6--对象的大小
template <typename tp>
inline const size_t numbers<tp>::size() const
{
    return numsLen;
}
/*--------------------------------------------------------*/
//7--重载下标运算符
template <typename tp>
inline tp &numbers<tp>::operator[](const size_t index) const
{
    return numsPtr[index];
}
/*--------------------------------------------------------*/
//8--深度拷贝
template <typename tp>
numbers<tp> &numbers<tp>::operator=(const numbers<tp> &nums)
{
    if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))//非空串的深度拷贝
    {
        numsLen = nums.numsLen;
        delete[] numsPtr;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = *(nums.numsPtr + i);
        }
    }
    if((numsPtr == nullptr)&&(nums.numsPtr != nullptr))//调用对象为空,操作对象非空
    {
        numsLen = nums.numsLen;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            this->at(i) = *(nums.numsPtr + i);
        }
    }
    if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))//调用对象非空,操作对象为空
    {
        numsLen = 0;
        delete [] numsPtr;
        numsPtr = nullptr;
    }
    
    return *this;
}
/*--------------------------------------------------------*/
//10--添加元素
template <typename tp>
numbers<tp> numbers<tp>::operator+(const tp num) const
{
    numbers<tp> r_nums;
    if (numsPtr != nullptr)
    {
        r_nums = *this;
        tp *t_numsPtr = new tp[numsLen + 1];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(t_numsPtr + i) = this->at(i);
        }
        *(t_numsPtr + numsLen) = num;
        r_nums.numsLen++;
        delete[] r_nums.numsPtr;
        r_nums.numsPtr = t_numsPtr;
    }
    else
    {
        r_nums.numsLen = 1 + numsLen;
        r_nums.numsPtr = new tp[numsLen + 1]{num};
    }

    return r_nums;
}
//11--合并对象
template <typename tp>
numbers<tp> numbers<tp>::operator+(const numbers<tp> &nums) const
{
    numbers<tp> t_nums;
    if (numsPtr != nullptr)
    {
        t_nums = *this;
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            t_nums = t_nums + *(nums.numsPtr + i);
        }
    }
    else
    {
        t_nums = nums;
    }

    return t_nums;
}
/*--------------------------------------------------------*/
//12--判断数据在对象中是否存在
template <typename tp>
bool numbers<tp>::operator%(const tp num) const
{
    bool flag = false;
    if (numsPtr != nullptr)
    {
        for (size_t i = 0; i < numsLen; i++)
        {
            if (num == *(numsPtr + i))
            {
                flag = true;
                break;
            }
        }
    }
    return flag;
}
//13--判断子对象是否父对象的子串
template <typename tp>
bool numbers<tp>::operator%(const numbers<tp> &nums) const
{
    bool flag = false;
    size_t count = 1;
    if (numsLen > nums.numsLen)
    {
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            if ((*this) % (*(nums.numsPtr + i)))
            {
                count++;
                if (count == nums.numsLen)
                {
                    break;
                }
            }
        }
        if (count == nums.numsLen)
        {
            flag = true;
        }
    }
    if (nums.numsPtr == 0)
    {
        flag = true;
    }
    return flag;
}
/*--------------------------------------------------------*/
//14--返回数据出现的次数
template <typename tp>
size_t numbers<tp>::operator/(tp num) const
{
    size_t count = 0;
    if (numsPtr != nullptr)
    {
        for (size_t i = 0; i < numsLen; i++)
        {
            if (this->at(i) == num)
            {
                count++;
            }
        }
    }
    return count;
}
//15--返回两个对象共同的元素
template <typename tp>
numbers<tp> numbers<tp>::operator/(const numbers<tp> &nums) const
{
    numbers<tp> r_nums;
    if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
    {
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            if ((*this)% (*(nums.numsPtr + i)))
            {
                r_nums += (*(nums.numsPtr + i));
            }
        }
    }
    return r_nums;
}
/*--------------------------------------------------------*/
//16--删除对象中符合条件的元素
template <typename tp>
numbers<tp> numbers<tp>::operator-(const tp num) const
{
    numbers<tp> r_nums;
    if (numsPtr != nullptr)
    {
        for (size_t i = 0; i < numsLen; i++)
        {
            if (this->at(i) != num)
            {
                r_nums += *(numsPtr + i);
            }
        }
    }
    return r_nums;
}
//17--删除父对象中与子对象中重复的元素
template <typename tp>
numbers<tp> numbers<tp>::operator-(const numbers<tp>& nums) const
{
    numbers<tp> r_nums;
    size_t count = 0;
    if ((numsPtr != nullptr)&&(nums.numsPtr != nullptr))
    /*两个非空数字串*/
    {
        r_nums = *this;
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            if ((*this)%(*(nums.numsPtr + i)))
            {
                r_nums = r_nums - *(nums.numsPtr + i);    
            }     
        }
        if (r_nums.numsLen == 0)
        {
            delete [] r_nums.numsPtr;
            r_nums.numsPtr = nullptr;
        }
    }
    else if ((numsPtr != nullptr)&&(nums.numsPtr == nullptr))
    /*子串为空*/
    {
        r_nums = *this;
    }
    return r_nums;
}
//18--按索引删除元素(数据必须是size_t类型)失败返回空串
template <typename tp>
numbers<tp> numbers<tp>::operator-(const size_t index) const
{
    numbers<tp> r_nums;
    if ((index < numsLen ) && (numsPtr != nullptr))
    {
        for (size_t i = 0; i < index; i++)
        {
            r_nums = r_nums + *(numsPtr + i);
        }
        for (size_t i = index + 1; i < numsLen; i++)
        {
            r_nums = r_nums + *(numsPtr + i);
        }
    }
    return r_nums;
}
//19-翻转数据的正负
template <typename tp>
numbers<tp> numbers<tp>::operator-(void) const
{
    numbers<tp> r_nums;
    for (size_t i = 0; i < numsLen; i++)
    {
        r_nums += -*(numsPtr + i);
    }
    return r_nums;
}
#endif

优化isnumbers()函数
//0---判断是否是数字字符串
template <typename tp>
void numbers<tp>::isnumbers(const std::string &str)
{
    size_t s = str.size();
    if (str[0] != '-' && (!isdigit(str[0])))
    {
        std::cerr << "Cannot convert to a valid number!" << std::endl;
        exit(1);
    }
    if (str[0] == '-' || (isdigit(str[0])))
    {
        for (size_t i = 1; i < s; i++)
        {
            if (!isdigit(str[i]))
            {
                std::cerr << "Cannot convert to a valid number!" << std::endl;
                exit(1);
            }
        }
    }
}
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-10-4 23:19

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表