这段代码会导致内存泄漏吗？
#include <stdexept>
class MyClass
{
public:
MyClass()
{
throw std::runtime_error("Test");
}
};
int main()
{
try
{
MyClass * myClass = new MyClass;
}
catch (const std::exception & exc)
{
// Memory leak?
}
return 0;
}
分配的内存new永远不会被删除.这是内部处理,还是实际的内存泄漏？
我经常使用Boost强类型def实用程序来提高程序的安全性.例如,通过编写如下代码:
BOOST_STRONG_TYPEDEF(int, X)
BOOST_STRONG_TYPEDEF(int, Y)
BOOST_STRONG_TYPEDEF(int, Width)
BOOST_STRONG_TYPEDEF(int, Height)
struct Rect {
Rect(X x, Y y, Width w, Height h);
};
// Usage:
Rect rect(X(10), Y(20), Width(800), Height(600));
这里强大的typedef提高了代码的可读性和安全性.(如果参数以错误的顺序提供,编译器将报告错误,如果参数全部都不是这种情况int.)
我的问题是:
我正在为当地一所大学实施一个讲座捕捉项目.多个视频流将到达一台PC:演示者的桌面幻灯片,演示者自己的摄像机图像以及可选的数字白板捕获.这些传入流将由桌面应用程序管理,该应用程序显示,转码/混合并最终将它们保存到磁盘.将有一些配置选项,因为材料可以以各种方式分发:作为DVD上的Flash应用程序,作为在线Flash应用程序或作为Windows Media Player的视频点播流.
此应用程序应在Windows上运行.可选地,它可以支持其他平台,但它似乎不是高优先级.
GStreamer和DirectShow似乎都能够提供底层技术.我对Linux上的GStreamer有一点经验,我喜欢它的设计,所以我倾向于将它用于这个项目.但是,我不知道它在Windows上的支持程度如何.我找不到关于如何在Windows上构建GStreamer的最新文档.所以我担心在这个过程中我会陷入困境.
DirectShow似乎是一个更安全的选择,因为它使用得更广泛,并且在互联网上有更多可用的文档.
这里有没有人有在Windows上使用GStreamer的经验？它运作良好吗？我应该注意哪些问题？
编辑
我发现了GStreamer OSSBuilds网站,并能够快速实现一个简单的视频播放器(基于'playbin'元素).所以我想我会更进一步追求GStreamer路径.
使用udev我已经能够获得某个USB设备的这些信息:
idVendor: 13b1
idProduct: 0018
manufacturer:
product: USB 2.0 Network Adapter ver.2
serial: 00FFFF
现在我想获得与供应商和产品ID相关联的完整字符串.我发现该文件/usr/share/misc/usb.ids包含我正在寻找的信息:
13b1 Linksys
000b WUSB11 v4.0 802.11b Adapter
000d WUSB54G Wireless Adapter
0011 WUSB54GP v4.0 802.11g Adapter
0018 USB200M 10/100 Ethernet Adapter
001a HU200TS Wireless Adapter
001e WUSBF54G 802.11bg
0020 WUSB54GC 802.11g Adapter [ralink rt73]
0023 WUSB54GR
0024 WUSBF54G v1.1 802.11bg
但是,我不清楚应该如何在我的应用程序中检索此数据.是否有可用的API或我应该解析文件？如果我选择解析它,那么/usr/share/misc/usb.ids总是正确的位置？
在GoingNative活动中,在第2天的交互式面板中,在9分钟时,Chandler Carruth说:
指针会产生锯齿问题.他们放慢你的二进制文件速度而不加速它们.
这是什么意思？这可以用(简单)示例来说明吗？
与我的期望相反,这个程序有效:
#include <iostream>
namespace a { struct item{}; }
namespace b { struct item{}; }
template<typename T>
void func(T t) { do_func(t); }
int main()
{
func(a::item{});
func(b::item{});
}
namespace a { void do_func(item) { std::cout << "a::func\n"; } }
namespace b { void do_func(item) { std::cout << "b::func\n"; } }
输出:
a::func
b::func
在线编译器验证:
如果瞬间func<T>发生在身体main然后我会期待a::do_func并且b::do_func尚未宣布.
这怎么办？
根据@Marc Claesen的说法,上述原因是:
在读取所有源之后执行模板实例化
但是,那么为什么这个代码并不能正常工作:
#include <iostream>
template<typename T>
void …该std::type_info课程不可复制.这使得将其存储在对象中以供以后使用变得困难.我该怎么办？
根据Threads和简单的Dead lock cure以及Herb Sutter中的答案,避免死锁的关键是使用锁层次结构.
有没有很好的C++库可以为此提供支持？我在Boost或Poco中找不到任何东西.
理想情况下,它是一个允许在编译时定义层次结构的系统.也许它看起来像这样:
template<class LowerLevelMutex>
class RankedMutex { ... };
class BottomMutex { ... };
typedef RankedMutex<BottomMutex> L1Mutex;
typedef RankedMutex<L1Mutex> L2Mutex;
typedef RankedMutex<L2Mutex> L3Mutex;
// ...
将参数传递给函数时,我总是假设逐个传递参数与传递它们包装在数组或结构或元组中没有什么不同.然而,一个简单的实验表明我错了.
使用GCC编译时的以下程序:
int test(int a, int b, int c, int d) {
return a + b + c + d;
}
int test(std::array<int, 4> arr) {
return arr[0] + arr[1] + arr[2] + arr[3];
}
struct abcd {
int a; int b; int c; int d;
};
int test(abcd s) {
return s.a + s.b + s.c + s.d;
}
int test(std::tuple<int, int, int, int> tup) {
return std::get<0>(tup) + std::get<1>(tup) + std::get<2>(tup) + std::get<3>(tup);
}
...产生各种装配输出:
impl_test(int, int, …使用下面的程序我尝试测试我可以用多快的速度写入磁盘std::ofstream.
在写入1 GiB文件时,我达到大约300 MiB/s.
但是,使用该cp命令的简单文件复制速度至少快两倍.
我的程序是否达到了硬件限制,还是可以更快？
#include <chrono>
#include <iostream>
#include <fstream>
char payload[1000 * 1000]; // 1 MB
void test(int MB)
{
// Configure buffer
char buffer[32 * 1000];
std::ofstream of("test.file");
of.rdbuf()->pubsetbuf(buffer, sizeof(buffer));
auto start_time = std::chrono::steady_clock::now();
// Write a total of 1 GB
for (auto i = 0; i != MB; ++i)
{
of.write(payload, sizeof(payload));
}
double elapsed_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now() - start_time).count();
double megabytes_per_ns = 1e3 / elapsed_ns;
double megabytes_per_s = 1e9 * megabytes_per_ns; …