c++数据测试

最新推荐文章于 2024-08-22 23:21:41 发布
最新推荐文章于 2024-08-22 23:21:41 发布
阅读量108 收藏
点赞数
分类专栏： c++速成学习笔记 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tankeven/article/details/134389916
版权

SafeQueue.h

#pragma once
#include <iostream>
#include <string>
#include <cstring>
 #include <queue>
 #include <unistd.h>
 #include <mutex>
 #include <condition_variable>
#include <pthread.h>


template <typename T>
class SafeQueue {
public:
    using lock_type = std::unique_lock<std::mutex>;
public:
    SafeQueue() = default;
    // 手动添加拷贝构造
    SafeQueue(const SafeQueue& other)
    {
        // std::lock_guard<std::mutex> lock(other.mutex_);
        lock_type lock{mutex_};
        queue_ = other.queue_;
    }
    ~SafeQueue() = default;
    template<typename IT>
    void push(IT &&item) {
        static_assert(std::is_same<T, std::decay_t<IT>>::value, "Item type is not convertible!!!");
        {
        lock_type lock{mutex_};
        queue_.emplace(std::forward<IT>(item));
        }
        cv_.notify_one();
    }
    auto pop() -> T {
        lock_type lock{mutex_};
        cv_.wait(lock, [&]() { return !queue_.empty(); });
        auto front = std::move(queue_.front());
        queue_.pop();
        return front;
    }

    // - `empty()`：检查队列是否为空。
    // 通过创建互斥锁对象，锁定临界区并使用STL `queue::empty()` 成员函数检查元素是否为空来实现。
    bool empty() const {
        lock_type lock{mutex_};
        return queue_.empty();
    }

    // - `size()`：返回队列中元素的数量。
    // 通过创建互斥锁对象，锁定临界区并使用STL `queue::size()` 成员函数返回队列中元素的数量来实现。
    size_t size() const {
        lock_type lock{mutex_};
        return queue_.size();
    }
    
    // - `swap()`：用另一个队列对象交换这个队列对象的内容。
    // 由于交换操作涉及两个不同的队列对象，因此需要创建两个互斥锁对象分别锁定两个队列对象，
    // 然后使用STL `queue::swap()` 成员函数在两个队列对象之间交换内容来实现。
    void swap(SafeQueue<T>& other) {
        lock_type lock1{mutex_, std::defer_lock};
        lock_type lock2{other.mutex_, std::defer_lock};
        std::lock(lock1, lock2);
        std::swap(queue_, other.queue_);
    }

    // - `clear()`：清空队列中的所有元素。
    // 通过创建互斥锁对象，锁定临界区并使用STL `queue::swap()` 成员函数在队列对象中交换备用队列来实现。
    void clear() {
        lock_type lock{mutex_};
        std::queue<T>().swap(queue_);
    }

private:
    std::queue<T> queue_;
    mutable std::mutex mutex_;
    // std::mutex mutex_;
    std::condition_variable cv_;
};

DataBase.h

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <sstream>
#include <mutex>
#include <vector>
#include "SafeQueue.h"

using namespace std;

template<typename T>
using SafeQueue2D = SafeQueue<SafeQueue<T>>;
SafeQueue2D<int> testQ;

void init()
{
    for (int i = 0; i < 5; i++)
    {
        SafeQueue<int> row;
        for (int j = 0; j < 5; j++)
        {
            row.push(j + i * 5);
        }
        testQ.push(row);
    }
    
}

void print()
{
    init();
    std::ostringstream ss;
    while (!testQ.empty()) {
        auto row = testQ.pop();
        while (!row.empty()) {
            ss << row.pop() << " ";
        }
        ss << '\n'; // 一行结束
    }
    std::cout << ss.str() << std::endl;
}





template <typename T>
class DataBase {
public:
    DataBase() {
        // m_queue.
    }
    // T & getData(int type) const;
    // template <typename T>
    T& getData(int type) const {
        if(type == m_ulinkMsgType) {
            if(!m_dataulink.empty()) {
                return m_dataulink.back();
            } else {
                throw std::out_of_range("No data available for requested type");
            }
        } else if(type == m_dlinkMsgType) {
            if(!m_datadlink.empty()) {
                return m_datadlink.back();
            } else {
                throw std::out_of_range("No data available for requested type");
            }
        } else {
            throw std::invalid_argument("Invalid data type");
        }
    }
    
    // setData(int type, const T &data);
    void setData(int type, const T &data) {
        if(type == m_ulinkMsgType) {
            m_dataulink.push_back(data);
        } else if(type == m_dlinkMsgType) {
            m_datadlink.push_back(data);
        } else {
            throw std::invalid_argument("Invalid data type");
        }
    }

public:
    static SafeQueue<SafeQueue<T>> m_queue;
    static vector<T> m_dataulink;
    static vector<T> m_datadlink;
    static int m_ulinkMsgType;
    static int m_dlinkMsgType;
    // std::mutex m_mutex;
};


// 声明模板类中的静态成员变量
template <typename T>
SafeQueue<SafeQueue<T>> DataBase<T>::m_queue;
template <typename T>
vector<T> DataBase<T>::m_dataulink;
template <typename T>
vector<T> DataBase<T>::m_datadlink;
template <typename T>
int DataBase<T>::m_ulinkMsgType = 1;
template <typename T>
int DataBase<T>::m_dlinkMsgType = 2;

Config.h


#pragma once
#include <iostream>

typedef enum tag_enum_ulink_ {
    DB_ULINK_TYPE0 = 0,
    DB_ULINK_TYPE1,
    DB_ULINK_TYPE2,
    DB_ULINK_TYPE3,
    DB_ULINK_TYPE4,
    DB_ULINK_TYPE5,
} ULinkDataType;

typedef enum tag_enum_dlink_ {
    DB_DLINK_TYPE0 = 0,
    DB_DLINK_TYPE1,
    DB_DLINK_TYPE2,
    DB_DLINK_TYPE3,
    DB_DLINK_TYPE4,
    DB_TYPE5,
} DLinkDataType;

main.c

#include <iostream>
#include <string>
#include <cstring>
#include "DataBase.h"
#include "Config.h"

int main()
{

    std::cout << "hello c++" << std::endl;

    // DataBase<int> db;
    // db.m_queue[0].push(1);
    print();


    try {
        // 创建一个DataBase类的实例化对象 string类型
        DataBase<std::string> db;

        // 设置向量中的数据
        db.setData(DataBase<std::string>::m_ulinkMsgType, "this is a string for ulink Msg.");
        db.setData(DataBase<std::string>::m_dlinkMsgType, "this is a string for dlink Msg.");

        // 获取并输出向量中的数据
        std::cout << db.getData(DataBase<std::string>::m_ulinkMsgType) << std::endl; // 输出：this is a string for ulink Msg.
        std::cout << db.getData(DataBase<std::string>::m_dlinkMsgType) << std::endl; // 输出：this is a string for dlink Msg.

        // 尝试获取一个不存在的数据类型会抛出异常
        db.getData(3);  // 输出：Invalid data type
    } catch(const std::exception &e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }


    return 0;
}

测试结果：

hello c++
0 1 2 3 4 
5 6 7 8 9 
10 11 12 13 14 
15 16 17 18 19 
20 21 22 23 24 

this is a string for ulink Msg.
this is a string for dlink Msg.
Error: Invalid data type

根据上述声明，可以实现`getData()`和`setData()`方法的代码如下：

```c++
template <typename T>
T& DataBase<T>::getData(int type) const {
    if(type == m_ulinkMsgType) {
        if(!m_dataulink.empty()) {
            return m_dataulink.back();
        } else {
            throw std::out_of_range("No data available for requested type");
        }
    } else if(type == m_dlinkMsgType) {
        if(!m_datadlink.empty()) {
            return m_datadlink.back();
        } else {
            throw std::out_of_range("No data available for requested type");
        }
    } else {
        throw std::invalid_argument("Invalid data type");
    }
}

template <typename T>
void DataBase<T>::setData(int type

, const T &data) {
    if(type == m_ulinkMsgType) {
        m_dataulink.push_back(data);
    } else if(type == m_dlinkMsgType) {
        m_datadlink.push_back(data);
    } else {
        throw std::invalid_argument("Invalid data type");
    }
}
```

`getData()`方法接受一个整数类型参数，表示要获取的数据类型。如果请求的数据类型为`m_ulinkMsgType`或`m_dlinkMsgType`（存储在静态成员变量中），则分别尝试从`m_dataulink`或`m_datadlink`向量的末尾获取数据，并返回。如果所请求的向量为空则抛出异常。

`setData()`方法接受要设置的数据及其类型参数。如果类型参数为`m_ulinkMsgType`或`m_dlinkMsgType`，则向对应的向量中插入数据。

以下是一个示例，展示如何使用`DataBase`类并测试其实现：

```c++
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
#include "DataBase.h"

// 声明模板类中的静态成员变量
template <typename T>
SafeQueue<SafeQueue<T>> DataBase<T>::m_queue;
template <typename T>
vector<T> DataBase<T>::m_dataulink;
template <typename T>
vector<T> DataBase<T>::m_datadlink;
template <typename T>
int DataBase<T>::m_ulinkMsgType = 1;
template <typename T>
int DataBase<T>::m_dlinkMsgType = 2;

int main() {

    try {
        // 创建一个DataBase类的实例化对象 string类型
        DataBase<std::string> db;

        // 设置向量中的数据
        db.setData(DataBase<std::string>::m_ulinkMsgType, "this is a string for ulink Msg.");
        db.setData(DataBase<std::string>::m_dlinkMsgType, "this is a string for dlink Msg.");

        // 获取并输出向量中的数据
        std::cout << db.getData(DataBase<std::string>::m_ulinkMsgType) << std::endl; // 输出：this is a string for ulink Msg.
        std::cout << db.getData(DataBase<std::string>::m_dlinkMsgType) << std::endl; // 输出：this is a string for dlink Msg.

        // 尝试获取一个不存在的数据类型会抛出异常
        db.getData(3);  // 输出：Invalid data type
    } catch(const std::exception &e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}
```

在这个示例中，我们首先创建了一个`DataBase<std::string>`的实例化对象，并将两个字符串存储到`m_dataulink`和`m_datadlink`向量中，分别使用`setData()`来设置这两个向量中的数据。

然后我们使用`getData()`方法分别获取这两个向量中的数据，并打印结果。最后，我们测试获取一个不存在的类型时是否引发异常。如果存在异常，则捕获并在标准错误流上输出。

需要注意的是，这个示例只测试了`DataBase`类的`setData()`和`getData()`方法，实际上，这里也只有`整数int`类型一个成员变量，而使用时，需要根据实际情况进行更多类型的测试。

tankeven
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++之测试用例的编写
qq_43384388的博客
08-18 314
一个基本的客户端对服务端自动发送测试语句接收测试数据的用例。断眼 assert() 用于调试debug。关于连接开了一定要close。
C++版题目随机测试数据编写器
m0_48463380的博客
09-11 1309
有许多OJ平台及各大比赛的出题人需要出很多的测试数据，但却自己编不出来？下面这些建议你看看（虽然网上有很多其他的bat版随机测试数据编写器，但是我还是喜欢用我这种C++版的）
c++编写评测机(1)
zhaoniuniu0309的博客，刚刚开始写博文的新手，有不对的地方请谅解。
07-18 763
最近闲得无聊，想用c++自己写一个评测机。一来为了提升个人c++实际应用能力，二来也能学习到不少知识。其实纯属是为了玩儿本评测机用纯c++编写，平台：devc++。可评测c++/c的程序，编译基于Mingw。由于用纯c++编写，什么乱七八糟的库都没用，所以本评测机会很(方便使用)粗糙，但对于简单的评测来说绰绰有余。模拟场景也没有那么细致，不过，开源嘛，有兴趣的读者可以自行改进，毕竟我写的没有那么好。
信息学奥赛一本通C++——算法和数据结构部分的题目和测试数据
05-07
信息学奥赛一本通C++书中，算法和数据结构部分的题目和测试数据，自己搭建OJ，还是做题测试都可以用。
c++如何写一个测试数据生成的代码
qq_46047971的博客
03-02 2163
#include <bits/stdc++.h> using namespace std; int main() { freopen("test.in","w",stdout); // 这里的意思是生成一个以.in结尾的文件，下面是文件的内容 for(int i=0;i<1e4;i++) cout<<rand()%10000<<endl;//随机生成10000个数 return 0; } 上面
c++如何测试数据
小飞猪的博客
10-11 1983
测试： 构造测试数据，可以把构造出的测试数据放在文件test.in里，将程序结果输出到文件test.out中。当然有时候不需要输出文件test.out,直接再屏幕上看输出结果就可以了。 如何方便的测试他们： （1）在程序中加入测试代码 freopen("test.in","r",stdin); freopen("test.otu","w",stdout); #endif (2)在行命令中重定向 例如，生成的可执行程序是abc,在Windows或Linux的行命令中这样输入和输出到文件。 abc<te
浅谈c++单元测试
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
08-02 4258
什么是单元测试？ 单元测试是指，对软件中的最小可测试单元在与程序其他部分相隔离的情况下进行检查和验证的工作，这里的最小可测试单元通常是指函数、接口或者类。 单元测试贯穿在开发的整个过程，并伴随着新功能模块的产生而进行。单元测试并不会花费更多的时间，与之相反，在提高代码效率、减少bug数量、有序开展开发工作上，单元测试发挥着很大的作用。...........................
数据测试工具代码 c++开发
06-30
本项目涉及的是“数据测试工具”的C++开发，这通常是指为验证和确保数据处理过程的正确性而创建的专用工具。 在数据测试工具的开发中，C++能够提供高级的内存管理和性能优化，同时支持模板、异常处理和多态性等特性...
C++ Test实验（动态测试）.docx
12-22
在动态测试方面，C++ Test提供了丰富的功能，包括自动化测试、自定义测试用例、数据源测试用例和桩函数机制。 1. 自动化测试 C++ Test能自动为源代码生成单元测试用例，这极大地提高了测试效率。只需选择要测试的...
c++test_c++登录测试程序_
10-01
在C++编程环境中，开发一个登录测试程序是为了验证用户身份并确保只有授权的用户能够访问特定的功能或数据，如交易查询。在这个上下文中，我们将会深入探讨C++中实现登录功能涉及的关键知识点。 1. **输入输出处理*...
c++标准容器性能测试程序
02-28
总结来说，这个"C++标准容器性能测试程序"旨在通过`vector_find_perf`来探索`std::vector`在执行查找操作时的性能表现，以及如何受数据量、数据分布等因素影响。这不仅有助于优化代码，还能帮助开发者更好地理解和...
C++数据精度问题(对浮点数保存指定位小数)
08-29
在C++编程中，数据精度问题常常涉及到浮点数的表示和处理。浮点数在计算机内部是以二进制形式存储的，这可能导致在进行浮点运算时出现精度损失。通常，`float`和`double`类型都有一定的精度限制，其中`float`大约能...
用C++获得可用作测试的随机数文件
m0_63566592的博客
01-16 383
使用C++内置函数获得20个测试用随机数的方法
C++匿名函数lamba简介
yao_tao11的博客
08-18 662
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
C++(11)类语法分析(2)
Once_day的回忆
08-17 1220
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
C语言：文件（写入，读取）
2301_80311224的博客
08-21 576
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
C语言——函数递归
2406_83392683的博客
08-18 394
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
【C++】链表
最新发布
qq_38801607的博客
08-22 413
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
Linux--C语言之动态内存分配
2201_75773226的博客
08-18 1145
void：是空类型，是数据类型的一种void*：是指针类型，是指针类型的一种，可以匹配任意类型的指针，类似于通配符。
C++程序设计测试题库
本资源提供了C++测试题及答案，涵盖了C++程序设计的基础知识，包括编程步骤、函数返回值类型、继承关系、数据封装等方面。通过本资源，读者可以了解C++程序设计的基本概念和原理，从而提高自己的编程能力。 1. 编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值