c insert 和 push_back throw length问题

最新推荐文章于 2024-04-27 20:19:18 发布

Orion-Vu

最新推荐文章于 2024-04-27 20:19:18 发布

阅读量198

点赞数

CC 4.0 BY-SA版权

分类专栏： c 文章标签： c

本文链接：https://blog.youkuaiyun.com/androidwubo/article/details/83412022

c 专栏收录该内容

2 篇文章

订阅专栏

原来的样子是

std::vector<int> gids;
gids.insert(gids.end(), 
            nodes[i]->getLiftFloors().begin(),
            nodes[i]->getLiftFloors().end());
flagGIDS[flag] = gids;

这样的话会报错

修改成这个样子就没事了

for (unsigned  int j= 0; j < nodes[i]->getLiftFloors().size(); ++j)
{
    gids.push_back(nodes[i]->getLiftFloors()[j]);
}
flagGIDS[flag] = gids;

这是个玄学的问题，有知道的可以帮忙解释一下

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

Orion-Vu

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

（C语言）insert

hua12ng的博客

11-29

8752

insert 题目：实现在字符串的内部增加字符串。 void insert(char * s1,char * s2, int n); 将s2指向的字符串的拷贝，添加到s1第n个字符的位置，原位置的字符后移。n=0时，s2增加到s1的首部； n=s1的字符串长度时，s2增加到s1的末尾。注意：使用空格字符来表示字符串的结束。例如source指向位置，依次保存了字符’a’，字符’b’，字符空格’ ...

vector源码分析

愤怒的弱鸡

08-14

1295

这里引用源码中的一段描述 In some terminology a %vector can be described as a dynamic C-style array, it offers fast and efficient access to individual elements in any order and saves the user from worrying aboutmemory and size allocation. vector毫不夸张得说就是有动态内存分配功能的传统数组

参与评论您还未登录，请先登录后发表或查看评论

【c语言】函数insert将一个指定的单精度数按递减规律插入数组num中，注：数组num中已有12个按照递减顺序排好序的单精度数

qq_62755550的博客

12-16

1549

//函数insert将一个指定的单精度数按递减规律插入数组num中 //注数组num中已有12个按照递减顺序排好序的单精度数 #include<stdio.h> #include<stdlib.h> #include<time.h> void insert(float num[13], float newnum); int main() { float nums[12]; srand((unsigned)time(NULL)); int i, j; for (.

c语言中insert函数,C ++ STL中的多集insert()函数

weixin_35032861的博客

05-21

1228

insert()C ++ STL中的多重集函数，可将元素从一个多重集到另一个多重集的位置从一个位置插入到另一个位置。使用的函数列表：ms.size()=返回多集的大小。ms.insert()=用于将元素插入多集。范例程式码#include#include#include#includeusingnamespacestd;intmain(){multisetms;multiset:...

insert函数

zhao_god的专栏

12-04

899

在C语言里如果想在集合里插入数据，比较麻烦，一般先把插入位置及以后的数据先后移动，然后再在该位置上插入新数据，过程需自己编写代码实现，Python下想对集合插入数据很简单用Insert函数就可以了，不需要写循环体移动数据，实际是Python在执行insert时帮大家完成了移动的操作。从运行结果可以看出在a列表位置为2的地方插入了数据100,而原来从2到最后的所有数据均向后移动了一个位置。列表.insert(位置，数据)

直接插入排序c/c++---InsertSort

qq_44416755的博客

03-15

449

/*插入排序 * *dev/c++ 输入结束 *按回车键 *再加上俩ctrl+z才能运行 */ #include&lt;cstdio&gt; #include&lt;iostream&gt; using namespace std; void insertSort(int a[],int len){ int temp; for(int i=0;i&lt;len;i++){ temp...

请注意，在接下来C++编码过程中，不要在意内存占用，速度优先！不要在意内存占用，速度优先！你需要实现一个数据结构，可以快速拼接复制以及读取，且绝对不会遇到修改/删除中间某个数据的情况。(类似于Scratch变量的效果) 请使得重复拼接10000000次单个int(也就是最后长度为10000001)达到0.5秒以内，随机读取这个数据10000000次达到0.1秒以内。可以参考数据结构树，这可能有助于快速复制与拼接，但深度不能太深，预计10-20层可以达到目标只要能提升速度的话，你可以使用任何头文件，包括第三方头文件。以下是要实现的函数: 0.My_Str(My_Str& a) 1.get_length() 2.int operator[](size_t l) 3.void push_front(My_Str& a) 4.void push_back(My_Str& a) 5.void push_front(int* a) 6.void push_back(int* a) 7.My_Stroperator+(const My_Str& In)

06-23

我们面临的问题是需要一个高效的数据结构来支持快速的拼接（push_front和push_back）和随机读取（operator[]），并且要支持高效的复制构造（My_Str(My_Str&a)）。要求重复拼接10000000次单个int（即10000001个元素）...

用c++编写一个函数基于链表实现一个LinkedList类内部元素的数据类型可以用template支持任意数据类型T，也可以简单固定为string，即T=string 要求支持： void push_back(const T& x) void push_front(const T& x) T pop_back() T pop_front() const T& peek_back() const T& peek_front() void remove(int i) 删除index为i的元素：front的index为0，back的index为length-1 bool contains(const T& x) bool is_empty() int length() void clear() string toString() ostream& operator<<(ostream& os, const LinkedList& list) istream& operator>>(istream& is, LinkedList& list) int find_first(const T& x) 返回x第一次出现的位置的index（最靠近front，也即index最小的），不存在则返回-1 int find_last(const T& x) 返回x最后一次出现的位置的index（最靠近back，也即index最大的），不存在则返回-1 void remove_first(const T& x) 删除第一次出现的x，如有 void remove_last(const T& x) 删除最后一次出现的x，如有 void remove(int start, int length) 从start开始删除（至多）length个元素 void insert(int i, const LinkedList& list) 将list中的元素逐一插入到i,i+1,i+2,...的位置 void replace(int start, int length, const LinkedList& list) 将start开始的（最多）length长的部分，替换成list中的元素 void sort() 将内部元素从小到大排序 LinkedList subList(int start, int length) 不要忘记必要的（不写会有问题的）：构造函数拷贝构造函数赋值运算符的重载析构函数

04-19

其中，push_back()函数实现了向链表的尾部添加元素，pop_front()函数实现了从链表的头部取出一个元素，并将该元素从链表中删除。empty()函数用于判断链表是否为空，size()函数用于获取链表中元素的个数。

#include <iostream> #include <stdexcept> using namespace std; template <typename T> class SinglyLinkedList { private: // 节点结构 struct Node { T data; Node* next; Node(const T& data) : data(data), next(nullptr) {} }; Node* head; // 头节点指针 Node* tail; // 尾节点指针 int length; // 链表长度 // 深拷贝辅助函数 void deepCopy(const SinglyLinkedList& other) { Node* current = other.head; while (current) { push_back(current->data); current = current->next; } } public: // 构造函数 SinglyLinkedList() : head(nullptr), tail(nullptr), length(0) {} // 深拷贝构造函数 SinglyLinkedList(const SinglyLinkedList& other) : head(nullptr), tail(nullptr), length(0) { deepCopy(other); } // 浅拷贝构造函数 SinglyLinkedList(SinglyLinkedList& other, bool shallow) : head(nullptr), tail(nullptr), length(0) { if (shallow) { // 浅拷贝：直接复制指针 head = other.head; tail = other.tail; length = other.length; } else { // 深拷贝 deepCopy(other); } } // 析构函数 ~SinglyLinkedList() { clear(); } // 深拷贝赋值运算符重载 SinglyLinkedList& operator=(const SinglyLinkedList& other) { if (this != &other) { clear(); // 释放现有资源 deepCopy(other); // 执行深拷贝 } return *this; } // 浅拷贝赋值运算符重载 SinglyLinkedList& operator=(SinglyLinkedList& other) { if (this != &other) { clear(); // 释放现有资源 // 直接复制指针（浅拷贝） head = other.head; tail = other.tail; length = other.length; } return *this; } // 头部插入 void push_front(const T& value) { Node* newNode = new Node(value); if (!head) { head = tail = newNode; } else { newNode->next = head; head = newNode; } length++; } // 尾部插入 void push_back(const T& value) { Node* newNode = new Node(value); if (!tail) { head = tail = newNode; } else { tail->next = newNode; tail = newNode; } length++; } // 指定位置插入 bool insert(int index, const T& value) { if (index < 0 || index > length) return false; if (index == 0) { push_front(value); } else if (index == length) { push_back(value); } else { Node* current = head; for (int i = 0; i < index - 1; i++) { current = current->next; } Node* newNode = new Node(value); newNode->next = current->next; current->next = newNode; length++; } return true; } // 删除头部 void pop_front() { if (!head) return; Node* temp = head; head = head->next; if (!head) tail = nullptr; delete temp; length--; } // 删除尾部 void pop_back() { if (!tail) return; if (head == tail) { delete head; head = tail = nullptr; } else { Node* current = head; while (current->next != tail) { current = current->next; } delete tail; tail = current; tail->next = nullptr; } length--; } // 删除指定位置 bool erase(int index) { if (index < 0 || index >= length) return false; if (index == 0) { pop_front(); } else if (index == length - 1) { pop_back(); } else { Node* prev = head; for (int i = 0; i < index - 1; i++) { prev = prev->next; } Node* toDelete = prev->next; prev->next = toDelete->next; delete toDelete; length--; } return true; } // 查找元素位置 int find(const T& value) const { Node* current = head; int index = 0; while (current) { if (current->data == value) { return index; } current = current->next; index++; } return -1; // 未找到 } // 获取链表长度 int size() const { return length; } // 判断链表是否为空 bool empty() const { return length == 0; } // 清空链表 void clear() { while (head) { Node* temp = head; head = head->next; delete temp; } tail = nullptr; length = 0; } // 反转链表 void reverse() { if (!head || !head->next) return; Node* prev = nullptr; Node* current = head; Node* next = nullptr; tail = head; // 新的尾节点是原来的头节点 while (current) { next = current->next; current->next = prev; prev = current; current = next; } head = prev; // 新的头节点是原来的尾节点 } // 访问指定位置元素 T& at(int index) { if (index < 0 || index >= length) { throw out_of_range("Index out of range"); } Node* current = head; for (int i = 0; i < index; i++) { current = current->next; } return current->data; } // 常量访问指定位置元素 const T& at(int index) const { if (index < 0 || index >= length) { throw out_of_range("Index out of range"); } Node* current = head; for (int i = 0; i < index; i++) { current = current->next; } return current->data; } // 打印链表 void print() const { Node* current = head; while (current) { cout << current->data; if (current->next) cout << " -> "; current = current->next; } cout << " -> nullptr" << endl; } }; // 示例使用 int main() { // 创建原始链表 SinglyLinkedList<int> list; list.push_back(1); list.push_back(2); list.push_back(3); cout << "原始链表: "; list.print(); // 1 -> 2 -> 3 -> nullptr // 深拷贝测试 SinglyLinkedList<int> deepCopy = list; // 使用深拷贝赋值 deepCopy.push_back(4); cout << "深拷贝后修改: "; deepCopy.print(); // 1 -> 2 -> 3 -> 4 -> nullptr cout << "原始链表: "; list.print(); // 1 -> 2 -> 3 -> nullptr (未受影响) // 浅拷贝测试 SinglyLinkedList<int> shallowCopy(list, true); // 使用浅拷贝构造函数 shallowCopy.push_back(5); cout << "浅拷贝后修改: "; shallowCopy.print(); // 1 -> 2 -> 3 -> 5 -> nullptr cout << "原始链表: "; list.print(); // 1 -> 2 -> 3 -> 5 -> nullptr (受影响) // 反转链表测试 list.reverse(); cout << "反转后链表: "; list.print(); // 5 -> 3 -> 2 -> 1 -> nullptr // 删除操作测试 list.erase(1); cout << "删除位置1后: "; list.print(); // 5 -> 2 -> 1 -> nullptr // 查找操作测试 cout << "元素2的位置: " << list.find(2) << endl; // 输出: 1 return 0; } 程序报错D:\mystudy\DataStructuresAndAlgorithms\02_list\SinglyLinkedList\main.cpp:26: error: no matching constructor for initialization of 'SinglyLinkedList<int>'

最新发布

08-21

list.push_back(2); list.push_back(3); // ... 然后第26行是：SinglyLinkedList<int> deepCopy = list; 所以，我们尝试将第26行改为显式调用拷贝构造函数： SinglyLinkedList<int> deepCopy(list); 如果...

#include <iostream> #include <vector> #include <string> #include <cstring> #include <cmath> #include <algorithm> #include <onnxruntime_cxx_api.h> // 检查浮点数有效性 bool is_valid_float(float value) { return !std::isnan(value) && std::isfinite(value); } int main() { try { // 1. 初始化ONNX Runtime环境 //Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "ONNX-Runtime"); Ort::Env env(ORT_LOGGING_LEVEL_VERBOSE, "ONNX-Runtime"); Ort::SessionOptions session_options; // 2. 加载ONNX模型 Ort::Session session(env, L"model.onnx", session_options); Ort::AllocatorWithDefaultOptions allocator; #if 0 auto model_metadata = session.GetModelMetadata(); auto pModelProducer = model_metadata.GetProducerNameAllocated(allocator); std::cout << "Model producer: " << pModelProducer.get() << "\n"; // 获取所有权重名称 size_t num_nodes = session.GetOverridableInitializerCount(); for (size_t i = 0; i < num_nodes; i++) { auto name_ptr = session.GetOverridableInitializerNameAllocated(i, allocator); std::cout << "Override name: " << *name_ptr << "\n"; } #endif // 3. 获取模型输入信息 size_t num_inputs = session.GetInputCount(); std::vector<std::string> input_names; std::vector<std::vector<int64_t>> input_shapes; std::vector<ONNXTensorElementDataType> input_types; std::cout << "===== Model Input Analysis =====\n"; for (size_t i = 0; i < num_inputs; i++) { auto name_ptr = session.GetInputNameAllocated(i, allocator); input_names.push_back(name_ptr.get()); auto type_info = session.GetInputTypeInfo(i); auto tensor_info = type_info.GetTensorTypeAndShapeInfo(); input_shapes.push_back(tensor_info.GetShape()); input_types.push_back(tensor_info.GetElementType()); std::cout << "Input [" << i << "]: " << input_names.back() << " | Type: " << input_types.back() << " | Shape: ["; for (auto dim : input_shapes.back()) { std::cout << dim << (dim == -1 ? "(dynamic)" : "") << ", "; } std::cout << "]\n"; } // 4. 获取模型输出信息 size_t num_outputs = session.GetOutputCount(); std::vector<std::string> output_names; std::vector<std::vector<int64_t>> output_shapes; std::cout << "\n===== Model Output Analysis =====\n"; for (size_t i = 0; i < num_outputs; i++) { auto name_ptr = session.GetOutputNameAllocated(i, allocator); output_names.push_back(name_ptr.get()); auto type_info = session.GetOutputTypeInfo(i); auto tensor_info = type_info.GetTensorTypeAndShapeInfo(); output_shapes.push_back(tensor_info.GetShape()); std::cout << "Output [" << i << "]: " << output_names.back() << " | Type: " << tensor_info.GetElementType() << " | Shape: ["; for (auto dim : output_shapes.back()) { std::cout << dim << (dim == -1 ? "(dynamic)" : "") << ", "; } std::cout << "]\n"; } // 5. 准备输入数据 //std::vector<int64_t> token_ids = { 35377 }; std::vector<int64_t> token_ids = { 100 }; //std::vector<int64_t> token_ids = { 70645 }; const size_t seq_length = token_ids.size(); const int64_t batch_size = 1; // 6. 动态调整输入形状 for (auto& shape : input_shapes) { for (size_t i = 0; i < shape.size(); i++) { if (shape[i] == -1) { if (i == 0) shape[i] = batch_size; // 第一维 = batch size else if (i == 1) shape[i] = seq_length; // 第二维 = 序列长度 else shape[i] = 1; // 其他维度设为1 } } } // 7. 创建输入张量 std::vector<Ort::Value> input_tensors; Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeDefault); std::cout << "\n===== Input Tensor Preparation =====\n"; for (size_t i = 0; i < num_inputs; i++) { const auto& name = input_names[i]; const auto& shape = input_shapes[i]; // 计算预期元素数量 size_t expected_elements = 1; for (auto dim : shape) expected_elements *= dim; std::cout << "Preparing input: " << name << " | Shape: ["; for (auto dim : shape) std::cout << dim << ", "; std::cout << "] | Elements: " << expected_elements << "\n"; if (name.find("input") != std::string::npos || name.find("ids") != std::string::npos) { if (shape.size() >= 2 && shape[0] == batch_size && shape[1] == seq_length) { input_tensors.emplace_back(Ort::Value::CreateTensor<int64_t>( memory_info, token_ids.data(), token_ids.size(), shape.data(), shape.size() )); std::cout << " Using token_ids data (size: " << token_ids.size() << ")\n"; } else { throw std::runtime_error("Input shape mismatch for token_ids"); } } else if (name.find("mask") != std::string::npos) { std::vector<int64_t> mask(seq_length, 1); input_tensors.emplace_back(Ort::Value::CreateTensor<int64_t>( memory_info, mask.data(), mask.size(), shape.data(), shape.size() )); std::cout << " Using attention_mask data\n"; } else if (name.find("type") != std::string::npos) { std::vector<int64_t> type_ids(seq_length, 0); input_tensors.emplace_back(Ort::Value::CreateTensor<int64_t>( memory_info, type_ids.data(), type_ids.size(), shape.data(), shape.size() )); std::cout << " Using token_type_ids data\n"; } else { throw std::runtime_error("Unsupported input type: " + name); } } // 8. 准备输入/输出名称指针 std::vector<const char*> input_names_ptr; for (const auto& name : input_names) input_names_ptr.push_back(name.c_str()); std::vector<const char*> output_names_ptr; for (const auto& name : output_names) output_names_ptr.push_back(name.c_str()); // 9. 运行模型推理 std::cout << "\n===== Running Inference =====\n"; auto output_tensors = session.Run( Ort::RunOptions{ nullptr }, input_names_ptr.data(), input_tensors.data(), input_tensors.size(), output_names_ptr.data(), output_names_ptr.size() ); // 10. 分析输出结果 std::cout << "\n===== Inference Results =====\n"; for (size_t i = 0; i < output_tensors.size(); i++) { auto& tensor = output_tensors[i]; if (!tensor.IsTensor()) { std::cerr << " Output [" << i << "] is not a tensor\n"; continue; } auto tensor_info = tensor.GetTensorTypeAndShapeInfo(); auto shape = tensor_info.GetShape(); size_t element_count = tensor_info.GetElementCount(); auto data_type = tensor_info.GetElementType(); std::cout << "Output [" << i << "]: " << output_names[i] << "\n"; std::cout << " Shape: ["; for (auto dim : shape) std::cout << dim << ", "; std::cout << "] | Elements: " << element_count << "\n"; // 关键诊断：检查输出维度 if (shape.size() >= 2 && shape[1] != seq_length) { std::cout << "WARNING: Output sequence length (" << shape[1] << ") does not match input length (" << seq_length << ")\n"; } // 详细输出分析 if (data_type == ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT) { double* data1 = tensor.GetTensorMutableData<double>(); float* data = tensor.GetTensorMutableData<float>(); // 统计有效值 int valid_count = 0; int nan_count = 0; float min_val = FLT_MAX, max_val = -FLT_MAX; for (size_t j = 0; j < element_count; j++) { if (is_valid_float(data[j])) { valid_count++; if (data[j] < min_val) min_val = data[j]; if (data[j] > max_val) max_val = data[j]; } else { nan_count++; } } std::cout << " Valid values: " << valid_count << "/" << element_count << "\n"; if (valid_count > 0) { std::cout << " Value range: [" << min_val << ", " << max_val << "]\n"; // 打印完整输出（元素少时） if (element_count <= 20) { std::cout << " Full output: "; for (size_t j = 0; j < element_count; j++) { std::cout << data[j] << " "; } std::cout << "\n"; } } } else { std::cout << " Data type: " << data_type << " (printing not supported)\n"; } std::cout << "\n"; } } catch (const Ort::Exception& e) { std::cerr << "ONNX Runtime Error: " << e.what() << "\n"; return 1; } catch (const std::exception& e) { std::cerr << "Error: " << e.what() << "\n"; return 1; } std::cout << "Inference completed. Press Enter to exit..."; getchar(); return 0; }这代码输入没问题，但是输出的向量是无效的float值

06-18

providers=['CPUExecutionProvider'])```##总结排查流程```mermaidgraphTDA[输出NaN/Inf]-->B[检查输入数据范围]B-->C[可视化模型排查高危操作]C-->D[启用详细日志]D-->E[逐层调试定位问题层]E-->F[添加数值保护或...

记录不熟悉的函数用法（C++）——insert

weixin_43836257的博客

04-27

2965

详细解读C++中insert函数的作用

C++中Insert函数的应用

2301_79087383的博客

10-18

9750

下面我们来理解一下这个循环，第一次调用insert函数之后insert函数返回的迭代器指向我们读入的str这个新元素，我们将此迭代器赋予it并不断循环，只要不断有str读入，it就会不断更新并指向新元素，所以就可以不断在将新元素插入到list首元素之前的位置。vector不支持push_back，但我们可以通过insert函数将元素插入到begin（）之前，且注意插入到vector末尾之外任何位置都可能很慢。将元素插入到vector、deque和string的任何位置都是合法的，然而，这样可能很耗时。

c语言insert作用,C++string中的insert()插入函数详解

weixin_32558567的博客

05-16

7586

下面通过代码给大家介绍c++ string insert() 函数，具体内容如下：basic_string& insert (size_type pos, const basic_string& str);在原串下标为pos的字符前插入字符串strbasic_string& insert (size_type pos, const basic_string& st...

C++容器的insert()函数有以下三种用法: 最终*it=val;