#include "stdlib.h"
#include "stdio.h"
#include "string.h"
int main(int argc, char* argv[])
{
int *test = malloc(15 * sizeof(int));
for(int i = 0;i < 15 ;i ++ )
printf("test is %i\n",test[i]);
memset(test,0,sizeof(int) * 15);
for(int i = 0 ; i < 15; i ++ )
printf("test after memset is %i\n",test[i]);
return 0;
}
我得到的输出非常奇怪:
test is 1142126264
test is 32526
...
test is 1701409394
test is 1869348978
test is 1694498930
test after memset is 0
test after memset is 0
test …from socket import socket, AF_INET, SOCK_STREAM
sock = socket(AF_INET, SOCK_STREAM)
sock.bind(("localhost", 7777))
sock.listen(1)
while True:
try:
connection, address = sock.accept()
print("connected from " + address)
received_message = sock.recv(300)
if not received_message:
break
connection.sendall(b"hello")
except KeyBoardInterrupt:
connection.close()
所以我试图把我的头包裹在套接字并拥有这个非常简单的脚本,但出于某种原因,我不能用a杀死这个脚本 KeyboardInterrupt
我怎么用KeyboardInterrupt 那个杀死脚本,为什么我不能用它杀死它KeyboardInterrupt？
我正在实现一个A我想要通过它专门管理的多态类型(称之为)std::shared_ptr.要允许shared_from_this在派生类的构造函数中A使用new,请使用然后将成员初始化std::shared_ptr为自身以自动管理其生命周期.为了帮助实现这一点,我决定使特定于类的operator new私有,并计划使用create()辅助函数而不是new和make_shared.设计可能看起来有点滑稽,但在我正在研究的UI库的上下文中是有意义的.最小可重复的例子如下:
struct A {
A() : m_sharedthis(this) {
}
void destroy(){
m_sharedthis = nullptr;
}
std::shared_ptr<A> self() const {
return m_sharedthis;
}
private:
friend std::shared_ptr<A> create();
std::shared_ptr<A> m_sharedthis;
};
std::shared_ptr<A> create(){
auto a = new A();
return a->self();
}
这编译并正常工作.当我将以下代码添加到正文时出现问题A:
struct A {
...
private:
void* operator new(size_t size){
return ::operator new(size);
}
void operator delete(void* ptr){ …从C ++中的函数返回值时，我们具有复制省略和（命名）返回值优化，可帮助我们创建更有效的代码。简而言之，下面的代码：
std::vector<int> make_vec_1(){
std::vector<int> v;
v.resize(1e6);
return v;
}
导致无提示的移动或直接构造到返回值的目标位置，而不是副本。围绕此的规则还意味着，在返回时显式移动返回的对象实际上会阻止这些优化。
std::vector<int> make_vec_2(){
std::vector<int> v;
v.resize(1e6);
return std::move(v); // BAD
}
如Scott Meyers的有效现代C ++项目25中所述，此版本可防止RVO 。
我的问题是，当返回类型不同但可以从一个或多个局部变量进行移动构造时会发生什么？考虑以下每个返回可选向量的函数：
std::optional<std::vector<int>> make_opt_vec_1(){
std::vector<int> v;
v.resize(1e6);
return v; // no move
}
std::optional<std::vector<int>> make_opt_vec_2(){
std::vector<int> v;
v.resize(1e6);
return std::move(v); // move
}
以下哪项是正确的？return std::move(v)起初，这行对我来说就像是一个危险信号，但我也怀疑这是正确的做法。以下两个返回一对向量的函数也是如此：
std::pair<std::vector<int>, std::vector<int>> make_vec_pair_1(){
std::vector<int> v1, v2;
v1.resize(1e6);
v2.resize(1e6);
return {v1, v2}; // no move
}
std::pair<std::vector<int>, std::vector<int>> make_vec_pair_2(){
std::vector<int> v1, v2;
v1.resize(1e6);
v2.resize(1e6);
return {std::move(v1), std::move(v2)}; // …背景
作为一种组织策略，我喜欢在复杂的函数中定义函数局部 lambda。它适用于封装多步逻辑、重复操作等（一般来说，函数适用的类型），但不会创建在使用范围之外可见的东西。这是约翰卡马克在他的关于内联代码优点的文章中阐述的风格的综合/替代品，因为它使所有东西都整齐地封装在它打算使用的函数中，同时还提供了一个（编译器识别的）名称来记录每个功能块。一个简单的、人为的例子可能看起来像这样（假设这里实际上发生了一些足够复杂的事情，值得使用这种风格）：
void printSomeNumbers(void)
{
const auto printNumber = [](auto number) {
std::cout << number << std::endl; // Non-trivial logic (maybe formatting) would go here
};
printNumber(1);
printNumber(2.0);
}
从语义上讲，这个函数的编译形式“应该”创建一个隐式定义的函子的实例，然后operator()()为每个提供的输入调用该函子，因为这就是在 C++ 中使用 lambda 的含义。然而，在优化的构建中，as-if 规则释放了编译器来内联一些东西，这意味着实际生成的代码可能只是内联 lambda 的内容并完全跳过定义/实例化函子。关于这种内联的讨论已经出现在过去的讨论中，这里和这里，以及其他地方。
题
在我找到的所有 lambda 内联问题和答案中，所提供的示例没有使用任何形式的lambda 捕获，而且它们在很大程度上也与将 lambda 作为参数传递给某物有关（即在std::for_each调用的上下文）。那么，我的问题是：编译器是否仍然可以内联捕获值的 lambda？更具体地说（因为我假设各种变量的生命周期在很大程度上影响了答案），编译器是否可以合理地内联一个仅在定义它的函数内部使用的 lambda，即使它捕获了一些东西（即局部变量）通过引用？
我的直觉是，内联应该是可能的，因为编译器可以完全了解所有代码和相关变量（包括它们相对于 lambda 的生命周期），但我并不乐观，我的汇编阅读技能也不是t 足够多地为我自己得到一个可靠的答案。
附加示例
以防万一我描述的特定用例不是很清楚，这里是上面 lambda 的一个修改版本，它利用了我描述的那种模式（再次，请忽略代码是人为的这一事实并且不必要地过于复杂）：
void printSomeNumbers(void)
{
std::ostringstream ss;
const auto …我知道如何用ifstream等读取文件.我只是坚持这个任务,我有一个充满常量的头文件和一个包含3个变量的文本文件(预算,hotelType,[event1,event2,...,eventn]).
#ifndef CONSTANTS_H_
#define CONSTANTS_H_
const string nameMap[] = { "Opening", "Soccer 1", "Soccer 2", "Soccer 3",
"Track and Field 1", "Track and Field 2", "Track and Field 3",
"Track and Field 4", "Swimming 1", "Swimming 2", "Gymnastics 1",
"Gymnastics 2", "Basketball 1", "Basketball 2", "Closing" };
const int eventPriceMap[] = { 2000, 80, 160, 500, 80, 100, 120, 140, 100, 100, 60, 100,
150, 300, 800 };
const int eventDateMap[] = { 0, 3, 6, 9, 1, 2, 3, …在这段代码中，我试图使用pair（int，pair（string，string））的initializer_list初始化类对象，但是在初始化map（int，pair（string，string））类型的类成员map2时遇到错误。
这是我的代码
#include <iostream>
#include <string>
#include <initializer_list>
#include <map>
using namespace std;
class contact{
private:
map <int,pair<string,string>> map2;
public:
contact(initializer_list<pair<int,pair<string,string>>> m):map2(m){}
void display(){
for (const auto& it:map2){
cout<<it.first;
}
}
};
int main() {
contact obj{
make_pair(4,make_pair("parul","agrawal")),
make_pair(5,make_pair("keshav","agrawal")),
};
obj.display();
return 0;
}
我正在使用可爱的nlohmann :: json进行一些JSON解析代码，并且为了帮助生成有用的错误消息，我为自己创建了一个打印JSON对象类型的函数。该函数接受一个json::value_t，它是一个完全按以下方式定义的枚举类json.hpp：
enum class value_t : std::uint8_t {
null,
object,
array,
string,
boolean,
number_integer,
number_unsigned,
number_float,
discarded
};
这是我的职能。我将其传递给json::value_t我，并且希望收到描述它的字符串。
std::string to_string(json::value_t type){
static const std::map<json::value_t, std::string> mapping = {
{json::value_t::null, "null"},
{json::value_t::object, "an object"},
{json::value_t::array, "an array"},
{json::value_t::string, "a string"},
{json::value_t::boolean, "a boolean"},
{json::value_t::number_integer, "an integer"},
{json::value_t::number_unsigned, "an unsigned integer"},
{json::value_t::number_float, "a floating point number"}
};
auto it = mapping.find(type);
if (it != mapping.end()){
return it->second;
}
return "a mystery value";
}
但是 …
一段时间以来，我似乎无法解决这个特定问题。例如，如果我有以下代码：
void foo(std::vector<int>::iterator &it) {
// ...
}
int main(){
std::vector<int> v{1,2,3};
foo(v.begin());
}
我会得到编译错误：
initial value of reference to non-const must be an lvalue.
我的猜测是我收到错误，因为a.begin()返回了一个右值。
如果是这样，以下表达式怎么可能起作用：
v.begin()=v.begin()++;
如果v.begin()是右值？
我对如何在C ++中调用函子的语法有疑问。在下面的代码中，为什么前两个示例有效，而第三次和第四次尝试却无效？
Also I can call ob (100); and it will output 300, but why can't I call Class(100) and have it output 300? Is there any way to use the overloaded operator () without instantiating a new object?
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
struct Class
{
void operator() (int a)
{
cout << a * 3 << " ";
}
} ob;
int main()
{
int arr[5] = { 1, 5, …