我有一个UDP服务器,它在缓冲区中获取消息,我想像邮箱一样存储.为此,我想创建一个可以保存这些传入消息的向量或映射,但是我的map或vector的值始终指向缓冲区的当前值.
如何将值正确存储在地图或矢量中？
为了演示我的问题,我编写了一个简单的静态示例来表示我的脚本中发生的事情:
#include <map>
#include <iostream>
int main(int argc, char const *argv[])
{
char buffer[65535];
std::map<int, char *> messages;
buffer = {'h','e','l','l','o'};
messages[0] = buffer;
buffer = {'h','o','w'};
messages[1] = buffer;
buffer = {'a','r','e'};
messages[2] = buffer;
buffer = {'y','o','u'};
messages[3] = buffer;
std::cout << messages[0] << std::endl;
std::cout << messages[1] << std::endl;
std::cout << messages[2] << std::endl;
std::cout << messages[3] << std::endl;
return 0;
}
结果是:
you
you
you
you
但我想得到:
hello
how
are
you
我该如何实现这一目标？
我的意思是,我如何使用我可以迭代的char来识别变量？因此,如果:
int cheese = 1337;
string identifier = "cheese";
如何使用此字符串"identifier"来标识变量cheese并返回其值？
我正在引用std :: atomic的cppreference示例,试图为堆栈添加Dtor函数:
#include<atomic>
template<class T>
struct node{
T data;
node* next;
node(const T&data):data(data),next(nullptr){}
};
template<class T>
class stack{
std::atomic<node<T>*> head;
public:
void push(const T&data)
{
node<T>* new_node=new node<T>(data);
new_node->next=head.load(std::memory_order_relaxed);
while(!std::atomic_compare_exchange_weak_explicit(
&head,
&new_node->next,
new_node,
std::memory_order_release,
std::memory_order_relaxed));
}
~stack()
{
node<T>* p=head;
while(p)
{
node<T>* next=p->next;
delete p;
p=next;
}
}
};
int main()
{
stack<int> s;
s.push(1);
s.push(2);
s.push(3);
return 0;
}
当程序执行到〜stack时,最后一个删除功能会提示崩溃,如下所示:
$ g++ myatomic.cpp -std=c++11
$ ./a.out
*** Error in `./a.out': munmap_chunk(): invalid pointer: 0x0000000000400b00 ***
======= Backtrace: …阅读了很多关于这个众所周知的问题,我发现并使用了"首次使用时创建",但主要问题是它会产生内存泄漏.
工作了一下,我做了一些轻微修改试图解决这个问题,我得到了一个解决方案:
1)使用全局静态指针代替本地静态指针
2)使用单独的函数删除对象.
例:
static myObject* myObjectPtr=nullptr;
static myObjectDel() {delete myObjectPtr;}
inline myObject& myObjectRef()
{
if(myObjectPtr==nullptr)
{
myObjectPtr=new myObjectPtr;
atexit(myObjectDel);
}
return(*myObjectPtr);
}
所以,我可以确保:
1)在首次使用之前创建对象.
2)上次使用后删除对象.
3)没有内存泄漏.
它适用于MS Visual Studio 2013,因为静态指针在程序启动时是零初始化的,但我不确定所有编译器和操作系统是否都这样做.
换句话说,它是便携式的吗？
谢谢你,抱歉我的英语不好(我不是英国人)
我正在使用这个代码,我从'网络某处获取,将一行文本拆分为"单词":
def SplitStringIntoWords(inputString, delimiters=' \t,'):
words = re.split('[' + delimiters + ']', inputString.strip())
return len(words), words
但是,我只是注意到它在多个内部空间(或制表符)上表现不佳.
numWords, words = SplitStringIntoWords('A B')
print(str(numWords) + ' words')
print(*words, sep=' ')
numWords, words = SplitStringIntoWords('A B')
print(str(numWords) + ' words')
print(*words, sep=' ')
numWords, words = SplitStringIntoWords('A B')
print(str(numWords) + ' words')
print(*words, sep=' ')
给
2个字A B.
3个字A B.
4个字A B.
折叠字符串内部的多个分隔符(在本例中为空格)的最佳方法是什么？
我真的只想为第一个X"单词"做这个,因为除了单词5之外的所有内容都是自由格式文本,我想我不应该折叠多个空格.但那将是"很高兴",而不是"必须拥有".
int main(){
std::cout << "Insert file name / or path. \n NOTE: ONLY INPUTS. DELETES PREVIOUS DATA.\nV.6" << std::endl;
std::string filen;
std::cin >> filen;
std::ofstream myFile;
try{
myFile.open(filen, std::ios::out);
}
catch(std::fstream::failure){
std::cout << "Could not open file!\n Make sure the name and data type are valid.";
system("pause");
}
while(true){
int press = getch();
if(press == 43) myFile.close();
if(press == 8){myFile << "\b" << " " << "\b";std::cout << "\b" << " " << "\b" << std::flush;}
if(press == 13){ myFile …我有以下结构.
typedef struct _abc{
int x;
int y;
} abc;
typedef struct _def{
abc a;
int b;
} def;
我想读一下abc里面的结构def.我是用以下方式做的.
int main() {
def x;
x.a = abc(); // Initializing 'a'
std::cout << &x.a << std::endl;
abc y = x.a; // Accessing 'a' later
std::cout << &y << std::endl;
}
但是从控制台输出我意识到对象引用已经改变.这意味着复制了结构属性.
在现实世界的场景中,structure abc每次访问它时都很大并且制作副本需要花费很多时间.
typedef struct _def{
_def(abc &_a){b=0;a=_a;}
abc &a;
int b;
} def;
int main() {
abc a;
def x(a);
std::cout << &x.a …静态数据类型是在内存中具有固定大小的数据类型.当我们提前声明数组大小时,在内存中保留了那么多字节或空间,以后不能再增加.所以这样一个数组就是一个静态数据类型.
好.但我们可以使用指针或指针数组动态地将内存分配给数组.我没有清楚地了解整个概念.请帮忙
我正在研究一个小的"时间"函数库,只是为了更多地了解如何使用C++和函数.
我有一个被调用的函数 Time(int hh, int mm, int sec)
我希望如果用户输入Time(11, 9, 14)
我想将此值存储在内存中hh = 11; mm = 09; sec = 14;以便稍后使用.
我知道,如果我要使用cout我本来可以使用的cout << setw(2) << setfill('0') << mm << endl;
但是现在我想直接将值存储为int,我该怎么做？`
我试过time = (tt > 10) ? 0 + mm : mm;但我想这就像做基本的加法0 + 9 = 9.
这是一个后续问题
已经正确回答.但是我在下面尝试了自己的解决方案
#include <type_traits>
template <typename T, typename enable = void> struct Traits {
static const bool value = false;
};
template <typename T> struct Traits<T,std::enable_if<std::is_reference<T>::value>> {
static const bool value = Traits<typename std::remove_reference<T>::type>::value;
};
struct Zip{};
template <> struct Traits<Zip,void> {
static const bool value = true;
};
template <typename E>
void Execute(E && e){
static_assert(Traits<E>::value);
}
int main(){
auto z = Zip();
Execute(z);
}
理论是,如果正确的专业化失败,那么下一个最专业化的将是基于if T是参考的匹配的那个.如果这匹配,则引用被剥离,我们希望得到一个匹配.但这似乎不起作用.有没有办法解决这个问题,保持我的尝试精神？