编写C++代码时,之间存在任何区别:
#include <cstdlib>
和
#include <stdlib.h>
除了前者主要包含在std::命名空间内？
除了编码标准和风格之外还有什么理由可以使用一个而不是另一个？
让我先解释一下我对"魔法"的意思.我将使用Java中的两个示例:
Object类.+为String对象定义了运算符.这意味着不可能在纯(*)Java中实现Object和String类的实现.现在这就是我对"魔术"的意思:要实现这些类,您需要编译器的一些特殊支持.
我一直喜欢C++的是,据我所知,STL中没有这样的"神奇",即可以在纯C++中实现STL.
现在我的问题是:这是真的吗？或者是否有STL的部分无法在纯C++中实现并需要一些"魔术"/特殊编译器支持？
(*)"纯"是指不使用任何类库.
我想知道是否复制一个向量我正在用它的值复制向量(而这不适用于数组,深度复制需要一个循环或memcpy).
你能暗示解释一下吗？
问候
有一条规则说明std :: tuple的成员被破坏了吗？
例如,如果Function1返回一个std::tuple<std::unique_ptr<ClassA>, std::unique_ptr<ClassB>>to Function2,那么我可以确定(当Function2剩下的范围时)ClassB第二个成员ClassA引用的实例在第一个成员引用的实例之前被销毁吗？
std::tuple< std::unique_ptr< ClassA >, std::unique_ptr< ClassB > > Function1()
{
std::tuple< std::unique_ptr< ClassA >, std::unique_ptr< ClassB > > garbage;
get<0>(garbage).reset( /* ... */ );
get<1>(garbage).reset( /* ... */ );
return garbage;
}
void Function2()
{
auto to_be_destroyed = Function1();
// ... do something else
// to_be_destroyed leaves scope
// Is the instance of ClassB destroyed before the instance of ClassA?
}
我想使用BOOST_FOREACH迭代std :: map并编辑值.我不太明白.
typedef std::pair<int, int> IdSizePair_t;
std::map<int,int> mmap;
mmap[1] = 1;
mmap[2] = 2;
mmap[3] = 3;
BOOST_FOREACH( IdSizePair_t i, mmap )
i.second++;
// mmap should contain {2,3,4} here
当然,这并没有改变任何东西,因为我没有通过引用迭代.所以我替换了这一行(根据Boost文档中的示例):
BOOST_FOREACH( IdSizePair_t &i, mmap )
我得到编译器错误:
error C2440: 'initializing' :
cannot convert from 'std::pair<_Ty1,_Ty2>' to 'IdSizePair_t &'
with
[
_Ty1=const int,
_Ty2=int
]
有什么建议？
我想做什么:我想将2个,3个或N个向量锁定在一起,而不是将它们复制到元组中.也就是说,将冗长放在一边,例如:
vector<int> v1 = { 1, 2, 3, 4, 5};
vector<double> v2 = { 11, 22, 33, 44, 55};
vector<long> v3 = {111, 222, 333, 444, 555};
typedef tuple<int&,double&,long&> tup_t;
sort(zip(v1,v2,v3),[](tup_t t1, tup_t t2){ return t1.get<0>() > t2.get<0>(); });
for(auto& t : zip(v1,v2,v3))
cout << t.get<0>() << " " << t.get<1>() << " " << t.get<2>() << endl;
这应输出:
5 55 555
4 44 444
...
1 11 111
我现在是怎么做的:我已经实现了自己的快速排序,我传递的第一个数组用于比较,排列应用于所有其他数组.我只是无法弄清楚如何重用std :: sort来解决我的问题(例如提取排列).
我试过的: boost :: zip_iterator …
我读过这个
"多个线程可以同时读写不同的shared_ptr对象,即使这些对象是共享所有权的副本." (MSDN:标准C++库中的线程安全性)
这是否意味着更改shared_ptr对象是安全的？
例如,下一个代码是安全的:
shared_ptr<myClass> global = make_shared<myClass>();
...
//In thread 1
shared_ptr<myClass> private = global;
...
//In thread 2
global = make_shared<myClass>();
...
在这种情况下,我可以确定线程1 private将具有global线程2分配的原始值或新值,但无论哪种方式,它将具有对myClass的有效shared_ptr？
==编辑==
只是为了解释我的动机.我想有一个共享指针来保存我的配置,我有一个线程池来处理请求.全局配置也是
如此global.
thread 1在开始处理请求时采用当前配置.
thread 2正在更新配置.(仅适用于未来的请求)
如果它工作,我可以更新配置,而不会在请求处理过程中中断它.
std::vector<int> a;
std::vector<int> b;
std::vector<int> c;
我想通过附加b's和c's元素来连接这三个向量a.哪种方法最好,为什么？
1)使用vector::insert:
a.reserve(a.size() + b.size() + c.size());
a.insert(a.end(), b.begin(), b.end());
a.insert(a.end(), c.begin(), c.end());
b.clear();
c.clear();
2)使用std::copy:
a.reserve(a.size() + b.size() + c.size());
std::copy(b.begin(), b.end(), std::inserter(a, a.end()));
std::copy(c.begin(), c.end(), std::inserter(a, a.end()));
b.clear();
c.clear();
3)使用std::move(from C++11):
a.reserve(a.size() + b.size() + c.size());
std::move(b.begin(), b.end(), std::inserter(a, a.end()));
std::move(c.begin(), c.end(), std::inserter(a, a.end()));
b.clear();
c.clear();
我强调引用不是指针,而是对象的别名.但是,我仍然不明白这对我作为一个程序员究竟意味着什么,即什么是引擎盖下的引用？
我认为理解这一点的最好方法是理解为什么我不能在地图中存储引用.
我知道我需要停止将引用视为指针的语法,只是不确定如何:/
当试图回答另一个Stackoverflow问题时,我意识到这个简单的C++ 11片段隐式阻塞了调用线程:
std::async(std::launch::async, run_async_task)
对我来说,这似乎是规范的C++ 11方式异步启动任务而不关心结果.相反,为了实现这一点,人们必须明确地创建和分离一个线程(参见上述问题的答案).
所以这是我的问题:关于安全性/正确性,是否有任何理由std::future必须阻止析构函数？如果它get仅仅阻止它就不够了,否则,如果我对返回值或异常不感兴趣,它只是火而忘记？