我需要动态创建一个整数数组.我发现在使用静态数组时的语法
int a [5]={0};
将所有元素的值正确初始化为0.
有没有办法在创建动态数组时做类似的事情
int* a = new int[size];
而不必遍历数组的所有元素？或者使用for循环赋值仍然是最佳方法？谢谢
我有一个QTcpSocket,我正在读一个循环.每次读取完整数据包或出现错误时,我都会手动检查循环内套接字的状态:
while(true){
if(socket->state()==QAbstractSocket::ConnectedState){
qDebug()<<"Socket status: connected. Looking for packets...";
if(socket->waitForReadyRead(2000)){
//...
}
当我执行de program时,一旦连接并且循环开始,它总是打印qDebug()<<"Socket status: connected. Looking for packets..."; 然后停留,waitForReadyRead直到一些数据准备好被读取.
问题是没有检测到断开连接.如果我断开网络与操作系统选项的连接,或者即使我拔掉以太网线,它的行为也是一样的:套接字状态等于QAbstractSocket::ConnectedState,所以它会继续,但当然没有收到任何东西.
我还试图检测连接disconnected()信号(在第一次连接后)到重新连接功能的断开连接:
// Detect disconnection in order to reconnect
connect(socket, SIGNAL(disconnected()), this, SLOT(reconnect()));
void MyClass::reconnect(){
qDebug()<<"Signal DISCONNECTED emitted. Now trying to reconnect";
panelGUI->mostrarValueOffline();
socket->close();
prepareSocket((Global::directionIPSerialServer).toLocal8Bit().data(), 8008, socket);
qDebug()<<"Reconnected? Status: "<<socket->state();
}
但是信号永远不会被发出,因为这段代码永远不会被执行.这是合乎逻辑的,因为看起来套接字状态总是如此ConnectedState.
如果我再次插入,连接将恢复并再次开始接收数据,但我确实想检测断开连接以在GUI上显示"已断开连接".
为什么QTcpSocket会以这种方式运行,我该如何解决这个问题呢？
编辑:我在类构造函数中创建套接字,然后初始化调用prepareSocket函数:
socket = new QTcpSocket();
socket->moveToThread(this);
bool prepareSocket(QString address, int port, QTcpSocket *socket) {
socket->connectToHost(address, port); …我刚刚编写了这个简短的C++程序来估算每秒钟的实际时钟周期数.
#include <iostream>
#include <time.h>
using namespace std;
int main () {
for(int i = 0; i < 10 ; i++) {
int first_clock = clock();
int first_time = time(NULL);
while(time(NULL) <= first_time) {}
int second_time = time(NULL);
int second_clock = clock();
cout << "Actual clocks per second = " << (second_clock - first_clock)/(second_time - first_time) << "\n";
cout << "CLOCKS_PER_SEC = " << CLOCKS_PER_SEC << "\n";
}
return 0;
}
当我运行程序时,我得到的输出看起来像这样.
Actual clocks per second = 199139
CLOCKS_PER_SEC = …我正在编写一个DirectX游戏,当我在Optimus笔记本电脑上运行它时会使用英特尔GPU,导致可怕的性能.如果我使用上下文菜单强制NVIDIA GPU或将我的可执行文件重命名为bf3.exe或其他一些着名的游戏可执行文件名称,性能就像预期的那样.
显然,当我必须重新分配我的游戏时,这两种方法都不是可接受的解决方案,那么有没有办法以编程方式强制笔记本电脑使用NVIDIA GPU？
我已经尝试使用DirectX来枚举适配器(IDirect3D9 :: GetAdapterCount,IDirect3D9 :: GetAdapterIdentifier)并且它不起作用:仅报告1个GPU(正在使用的GPU).
According to cppreference.com, std::map::operator[] for non-existing value does zero-initialization.
However, the same site does not mention zero-initialization for std::unordered_map::operator[], except it does have an example which relies on this.
Of course this is just a reference site, not the standard. So, is the code below ok or not?
#include <unordered_map>
int main() {
std::unordered_map<int, int> map;
return map[42]; // is this guaranteed to return 0?
}
C++20 允许使用auto函数参数类型。
它是否还允许auto用作函数参数类型的模板参数占位符（不相似，但在某种程度上符合C++17 template<auto>的精神）？
所以下面的代码，在 C++20 之前：
template<typename First, typename Second>
void printPair(const std::pair<First, Second>& p) {
std::cout << p.first << ", " << p.second;
}
可以写成：
void printPair(const std::pair<auto, auto>& p) {
std::cout << p.first << ", " << p.second;
}
它确实可以编译并与概念的实验性 GCC 实现一起很好地工作。
它是 C++20 的合法语法吗？
Clang 和 GCC不同意接受此代码。
什么是标准要求的行为？
#include <utility>
#include <iostream>
#include <vector>
int main()
{
std::vector pairs = {std::pair{1,11},{2,22}, {3,33}};
for (const auto& p: pairs) {
std::cout << p.second << std::endl;
}
}
注意：我知道这是 C++，所以标准可能是模糊的，但我认为一种行为是正确的。
我对 C++ 相当陌生，当我在构造函数和析构函数的行为中徘徊时，我发现了这个问题：
#include <iostream>
struct Student {
std::string a;
~Student() {
std::cout << "Destructor called\n";
}
} S;
int main() {
std::cout << "Before assigning to S\n";
S = {""};
std::cout << "After assigning to S\n";
}
当我编译上面的代码g++并运行它时，它会打印：
Before assigning to S
Destructor called
After assigning to S
Destructor called
但是当我更改std::string a;为 时const char *a;，它会打印：
Before assigning to S
After assigning to S
Destructor called
谁能解释为什么这一变化使析构函数少运行一次？
我正在阅读关于并发的“现代 C++ 编程手册，第 2 版”的第 8 章，偶然发现了一些让我感到困惑的东西。
作者使用std::thread和实现了不同版本的并行映射和缩减功能std::async。实现非常接近；例如，parallel_map函数的核心是
// parallel_map using std::async
...
tasks.emplace_back(std::async(
std::launch::async,
[=, &f] {std::transform(begin, last, begin, std::forward<F>(f)); }));
...
// parallel_map using std::thread
...
threads.emplace_back([=, &f] {std::transform(begin, last, begin, std::forward<F>(f)); });
...
完整的代码可以发现这里的std::thread和那里的std::async。
让我感到困惑的是，书中报告的计算时间为std::async实现提供了显着且一致的优势。此外，作者承认这一事实是显而易见的，但没有提供任何理由的暗示：
如果我们将这个 [result with async] 与使用线程的并行版本的结果进行比较，我们会发现这些是更快的执行时间并且加速非常显着，尤其是对于
fold函数。
我在我的电脑上运行了上面的代码，尽管差异没有书中那么引人注目，但我发现std::async实现确实比那个更快std::thread。（作者后来还带来了这些算法的标准实现，它们甚至更快）。在我的计算机上，该代码以四个线程运行，这与我的 CPU 的物理内核数相对应。
也许我错过了一些东西，但为什么明显std::async应该比std::thread这个例子运行得更快？我的直觉是，std::async作为线程的更高级别实现，它应该至少花费与线程相同的时间，如果不是更多的话——显然我错了。这些发现是否如书中所建议的那样一致，其解释是什么？
为什么聚合推导中不支持大括号初始化列表但支持大括号省略？
#include <iostream>
template<typename T>
struct Test{
T t[2];
};
int main(){
Test t{{1,2}}; // #1
// Test t1{1,2} // #2
}
#1被GCC拒绝，而#2会被 GCC 接受。
此外，如果定义了 C 并且它的定义满足聚合类（[dcl.init.aggr]）的条件，假设任何依赖基类都没有虚函数和虚基类，并且初始化器是一个非-empty 花括号初始化列表或括号表达式列表，并且没有 C 的推导指南，该集合包含一个额外的函数模板，称为聚合推导候选，定义如下。令 X 1 ,...,X N是花括号初始化器列表或表达式列表的初始化器列表或指定初始化器列表的元素。对于每个 X i，让 e i是 C 或其（可能是递归的）子聚合之一的相应聚合元素，这些子聚合将由 X 初始化我 如果
- [1.5] 对于具有依赖非数组类型或具有值依赖边界的数组类型的任何聚合元素，不考虑大括号省略，并且
- [1.6] 假设每个作为包扩展的非尾随聚合元素不对应于初始化列表的任何元素，并且
- [1.7] 作为包扩展的尾随聚合元素被假定为对应于初始值设定项列表（如果有）的所有剩余元素。
如果对于任何 X i没有这样的聚合元素 e i，则不将聚合推导候选添加到集合中。聚合推导候选如上从假设构造函数 C(T 1 ,...,T n )导出
- 如果 e i是数组类型并且 x i是花括号初始化列表或字符串文字，则 …