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

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 技术交流 › C\C++交流 › C++学习
返回列表 发新帖
查看: 1071|回复: 0

[技术交流] C++学习

[复制链接]
bin554385863
发表于 2019-11-21 18:17:27 | 显示全部楼层 |阅读模式

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

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

x
numbers.TXT
时间:2019年11月20日22:18:43;
作用:仿照C++ string用来处理数字串的类;
构造函数:
//默认构造
numbers():numsLen(0), numsPtr(nullptr){}
//使用C风格数字数组构造
numbers(const tp *arr, const size_t arrSize);
//可变参数构造
numbers(std::initializer_list<tp> list);
//拷贝构造
numbers(const numbers<tp>& nums);
****************************************************
成员函数

at():
按索引获取数字串的元素;
按索引修改元素的值;

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

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

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

-(删)
删除对象中指定的数据;
删除父对象中与子对象相同的数据;

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

/(查):
返回数据在对象中出现的次数;
返回对象与对象相同的元素;
numbers.h
#ifndef NUMBERS_H
#define NUMBERS_H
#include <iostream>
#include <initializer_list>
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);
    //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;
    //11--合并对象
    numbers<tp> operator+(const numbers<tp> &nums) const;
    /*--------------------------------------------------------*/
    //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/(numbers<tp> &nums) const;
    /*--------------------------------------------------------*/
    //16--删除元素
    numbers<tp> operator-(const tp num) const;
    //17--删除父对象中与子对象中重复的元素
    numbers<tp> operator-(const numbers<tp> &nums) const;
    //18--按索引删除元素(数据必须是size_t类型)失败返回空串
    numbers<tp> operator-(const size_t index) const;
    /*--------------------------------------------------------*/
    ~numbers()
    {
        delete[] numsPtr;
    }
};

#endif
numbers.cpp
#include "numbers.h"
//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);
    }
}
//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) : numsLen(nums.numsLen)
{
    numsPtr = new tp[numsLen];
    for (size_t i = 0; i < numsLen; i++)
    {
        *(numsPtr + i) = *(nums.numsPtr + i);
    }
}
/*--------------------------------------------------------------------*/
//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)
    {
        numsLen = nums.numsLen;
        delete[] numsPtr;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < numsLen; i++)
        {
            *(numsPtr + i) = *(nums.numsPtr + i);
        }
    }
    else
    {
        numsLen = nums.numsLen;
        numsPtr = new tp[numsLen];
        for (size_t i = 0; i < nums.numsLen; i++)
        {
            this->at(i) = *(nums.numsPtr + i);
        }
    }
    return *this;
}
/*--------------------------------------------------------*/
//10--添加元素
template <typename tp>
numbers<tp> numbers<tp>::operator+(const tp num) const
{
    numbers<tp> t_nums = *this;
    if (t_nums.numsPtr != nullptr)
    {
        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;
        t_nums.numsLen++;
        delete[] t_nums.numsPtr;
        t_nums.numsPtr = t_numsPtr;
    }
    else
    {
        t_nums.numsLen+=1;
        t_nums.numsPtr = new tp[numsLen]{num};
    }

    return t_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/(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 = 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 = 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++)
        {
            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-(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;
}
=================================================================================
main.c
#include "numbers.cpp"
int main(int argc, char const *argv[])
{
    numbers<int> a = {1}, b = {2}, c, z, d = {1, 2, 3}, e = {7, 9, 10}, f = {1,2,3,9,2,12};
    z = a + 2 + 3 + b + c + 4 + 5 + b + c;//测试+号重载,可以连加但必须数字串对象开头
    std::cout << z << std::endl;//测试<<
    std::cout<<z%1<<" "<<z%e<<" "<<z%f<<std::endl;//测试%重载,数字串对象必须在首位
    std::cout<<z/2<<"\n"<<z/f<<"\n"<<z/e<<std::endl;//测试\号重载,
    numbers<int> nums0 = {1,2,2,3,6,8,69,6,2,2,5,899};
    std::cout<<nums0<<std::endl;//测试-号重载,数字串必须对象在首位
    numbers<int> nums1;
    nums0 = nums0 - nums1;//
    std::cout<<"空串测试"<<nums0<<std::endl;
    nums0 = nums0 - 899;//
    std::cout<<"数字测试"<<nums0<<std::endl;
    nums0 = nums0 - (size_t)0;//
    std::cout<<"索引测试"<<nums0<<std::endl;
    nums0 = nums0 - z;//
    std::cout<<"非空对象测试(有相同元素)"<<nums0<<std::endl;
    nums0 = nums0 - e;//
    std::cout<<"非空对象测试(无相同元素)"<<nums0<<std::endl;
    return 0;
}
----------------------------------------------------------------------------------------
Microsoft Windows [版本 10.0.18363.476]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.1\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-n5ukogix.do5 --stdout=Microsoft-MIEngine-Out-c5k34mn0.wwi --stderr=Microsoft-MIEngine-Error-k43i2w1i.n55 --pid=Microsoft-MIEngine-Pid-mqrubay4.n0f --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
1 2 3 2 4 5 2
1 0 0
3
1 2 3 2

1 2 2 3 6 8 69 6 2 2 5 899
空串测试1 2 2 3 6 8 69 6 2 2 5 899
数字测试1 2 2 3 6 8 69 6 2 2 5
索引测试2 2 3 6 8 69 6 2 2 5
非空对象测试(有相同元素)6 8 69 6
非空对象测试(无相同元素)6 8 69 6

E:\Users\admin\Documents\VScode>
想知道小甲鱼最近在做啥？请访问 -> ilovefishc.com
回复

使用道具 举报

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

本版积分规则

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

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

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

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