我正在编写一个应用程序,需要大量内存用于缓存目的,正如我在此描述的那样.现在我正在玩一些malloc/new结构来弄清楚我是如何实现它的.我做了一个奇怪的观察:
#include <stdio.h>
#include <stdlib.h>
int main(void) {
while(1) {
char *foo = (char*)malloc(1024);// new char[1024];
if(foo == NULL) {
printf("Couldn't alloc\n");
fflush(stdout);
return 0;
}
}
return 0;
}
为什么永远不会达到printf？如果我的系统运行的内存,malloc的据说返回NULL,因为它是解释在这里.但我总是收到SIGKILL(我正在使用linux ......).
看看这段代码:
#include <iostream>
#include <string>
void foo(int(*f)()) {
std::cout << f() << std::endl;
}
void foo(std::string(*f)()) {
std::string s = f();
std::cout << s << std::endl;
}
int main() {
auto bar = [] () -> std::string {
return std::string("bla");
};
foo(bar);
return 0;
}
用它编译
g++ -o test test.cpp -std=c++11
导致:
bla
喜欢它应该做的.用它编译
clang++ -o test test.cpp -std=c++11 -stdlib=libc++
导致:
zsh: illegal hardware instruction ./test
并用它编译
clang++ -o test test.cpp -std=c++11 -stdlib=stdlibc++
还导致:
zsh: illegal hardware instruction ./test
Clang/GCC版本: …
我想做的应该很容易,但我不明白......
我想要做的就是在某个特定时间点在后台启动类的成员函数.该功能的结果也应该是"外部"可用的.所以我想在构造函数中准备任务(设置future变量,...)并在稍后的某个时间启动它.
我试图结合std ::(packaged_task | async | future),但我没有让它工作.
这段代码不会编译,但我认为它显示了我想要做的事情:
class foo {
private:
// This function shall run in background as a thread
// when it gets triggered to start at some certain point
bool do_something() { return true; }
std::packaged_task<bool()> task;
std::future<bool> result;
public:
foo() :
task(do_something), // yes, that's wrong, but how to do it right?
result(task.get_future())
{
// do some initialization stuff
.....
}
~foo() {}
void start() {
// Start Task as asynchron thread
std::async as(std::launch::async, …我想扩展 Python 枚举以支持未定义的值。
我的用例：我想从 Enums 中受益（例如，能够用说话的名字来寻址/比较已知条目），但我也希望它支持未知值。如果值后面没有名称， str 应该简单地打印值的 str 表示并且比较应该失败。
让我给你一个简短的例子，我想要什么：
from enum import Enum
class Foo(Enum):
A = 1
B = 2
C = 3
def __str__(self):
return self.name
print(Foo(1)) # prints 'A'
print(Foo(2)) # print 'B'
print(Foo(3)) # prints 'C'
print(Foo(1) == Foo.A) # prints 'true'
print(Foo(4)) # I'd expect '4'
print(Foo(123)) # I'd expect '123'
print(Foo(123) == Foo.A) # I'd expect False
当然，最后几行失败了。
有没有办法扩展枚举，或者是否有另一种简单的 Pythonic 方法？（请不要使用第三方库。）
在 C++11 项目中，我使用的是 C 风格的第三方库（在我的例子中是 curl），它需要 C 风格的回调。
为了实现这一点，我使用了“指针到成员”运算符：
size_t c_callback_wrapper(char *ptr, size_t size, size_t nmemb, void *userdata)
{
MyClass *p = (MyClass*)userdata;
return (p->*&MyClass::actualCallback)(ptr, size, nmemb, userdata);
}
void Myclass::performSomething() {
// register callback function
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, c_callback_wrapper);
// register userdata
curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);
...
res = curl_easy_perform(curl);
}
这个解决方案确实有效，但对我来说并不令人满意。
我真正想做的是在我的注册函数中编写一个 lambda。
优势通常是局部性：我将能够捕获一些局部变量，并且无需编写复杂的“actualCallback”成员例程。
我已经读过，当 Lambda 捕获变量时，似乎不可能将它们用作 C 风格的函数。
有什么方法可以使用一些技巧来实现这一目标吗？（例如玩 lambdas 的调用约定，...）
谢谢
从我的 gitlab 服务器克隆 git 存储库后，它不会检出 master，因为 origin/HEAD 指向某个其他分支“origin/foo”。在 gitlab 中，默认分支设置为 master。
如何将 origin/HEAD 从 'origin/foo' 移动到指向 'origin/master'，以便进一步的克隆自动检出 origin/master？
克隆后， git remote show origin 声明：
HEAD branch: foo
git remote -r 秒：
origin/HEAD -> origin/foo
我希望 HEAD 分支指向 master，尽管 - 在 gitlab 中 - 默认分支已经设置为 master。
我正在使用qtcreator(2.8.1)并且使用智能指针有一些奇怪的行为.
看看这个片段:
class myclass {
public:
void test() {};
};
....
std::shared_ptr<myclass> foo(new myclass);
foo->test();
std::unique_ptr<myclass> bar(new myclass);
bar->test();
如果我输入"foo->",会弹出代码完成窗口,但是如果我输入"bar->"则没有任何反应.
任何想法为什么代码完成只适用于shared_ptrs而不适用于unique_ptrs？
更新:知道我正在使用带有CMake和add_definitions的QT Creator(-std = c ++ 11)可能很重要.
我尝试使用 OpenSSL 和巨大的 RSA 密钥。
昨晚，我生成了一个 65536 位 RSA 密钥（花了我 6 个小时）。虽然 OpenSSL 似乎能够生成此类密钥，但它无法使用它们进行操作：
openssl rsautl -inkey 65536.pem -in text.txt -out foo.bar
RSA operation error
139666197399208:error:04067069:rsa routines:RSA_EAY_PUBLIC_DECRYPT:modulus too large:rsa_eay.c:644:
这么大的钥匙可以操作吗？
这是生成的密钥，因此您不需要自己生成密钥:)
我想要做的是编写一个小型的Manager/Handler类.经理分发和管理Handles.这样的句柄可以是例如简单的文件句柄.
如果消费者想要获得已经存在的句柄,那么管理者只需返回一个shared_ptr.如果句柄不存在,管理器将创建一个新句柄,然后返回shared_ptr.
在Manager内部,那些shared_ptr存储在一个简单的STL-Map中.如果分配的最后一个shared_ptr被删除,我希望我的经理删除相关的map-element,以便处理程序对象自动被破坏.
这听起来有点像垃圾收集(例如工作线程,它检查指针的使用次数),但我相信它可以更优雅地完成.
如何将管理器实例的引用传递给处理程序对象？(例如,像将unique_ptr(this)传递给新处理程序的构造函数)
#include <memory>
#include <iostream>
#include <map>
using namespace std;
/*
* Simple handler class, that actually does nothing.
* This could be e.g. a Filehandler class or sth. like that
*/
class Handler {
private:
int i;
public:
Handler(int i) :i(i) {}
~Handler() {}
// Say who you are.
void print(void) { cout << "I am handler # " << i << endl; }
};
/*
* This is the "manager" class, that manages all …看看这个易受攻击的片段:
int main(int argc, char **argv) {
printf(argv[1], "bla");
return 0;
}
在没有优化的情况下编译它会导致
./test "asd"
asd
./test "asd %s"
asd bla
./test "asd %0\$s"
asd %0$s
./test "asd %45\$s"
asd XDG_VTNR=7 <-- What the...
好吧,实际上似乎"%(number)\ $ s"试图将(数字)参数解释为字符串,查看堆栈的上方,我遇到了我的环境变量.在任何地方都使用这种格式字符串,特别是使用好奇的"\ $"？我找不到任何参考资料.
最后,通过优化编译启用它会导致:
*** invalid %N$ use detected ***
asd zsh: abort ./test "asd %46\$s"
我以前从未见过这样的错误.它从何而来？
(我使用的是Gentoo Linux/GCC 4.8.2/glibc 2.18)
在我的项目中,我使用一个名为Message的类,它继承自std :: ostringstream,打印出其他类类型的人类可读信息.
所以它的<<运算符多次重载我自己的类类型,我想打印出来.
class Message : public ostringstream
{
public:
Message() {};
virtual ~Message() {};
Message& operator <<(const MyTypeA &a) { return *this << a.getStr(); };
Message& operator <<(const MyTypeB &b) { return *this << b.identifier(); };
Message& operator <<(const MyTypeC &c) { return *this << c.foo(); };
// Pass everything unknown down to ostringstream, and always return a Message&
template<class T>
Message& operator <<(const T &t)
{
(std::ostringstream&)(*this) << t;
return *this;
}
};
没有模板
MyTypeA a,b;
Message …我想要做的事实上应该很简单,但我不知道如何以一种简单的方式实现它:
我想将无符号整数(32位)的值复制到无符号字符数组.数组中的表示必须始终为little endian.
在一个小端架构上我可以简单地做:
unsigned char array[sizeof(unsigned int)];
unsigned int i = 12345;
memcpy(array, &i, sizeof(unsigned int));
该表示将以小尾数表示.在大端架构上实现这一目标的最佳方法是什么？我如何在我的代码中找出我的架构的endianess？
我的项目使用C++ 11标准.
提前致谢!
看看这个片段:
#include <string>
#include <iostream>
#include <vector>
using namespace std;
class base {
public:
string foo;
base() {};
base(const base &orig) {
this->foo = orig.foo;
};
~base() {} ;
};
class derived : public base {
public:
string bar;
derived(const derived &orig) : base(orig) {
this->bar = orig.bar;
}
derived() : base() {} ;
~derived() {};
};
void asd(derived d)
{
// works fine
cout << d.foo << d.bar << endl;
}
int main(void)
{
vector<derived> v;
derived bla;
bla.foo …