我想知道如何malloc和free工作.
int main() {
unsigned char *p = (unsigned char*)malloc(4*sizeof(unsigned char));
memset(p,0,4);
strcpy((char*)p,"abcdabcd"); // **deliberately storing 8bytes**
cout << p;
free(p); // Obvious Crash, but I need how it works and why crash.
cout << p;
return 0;
}
如果答案在记忆水平上是深入的,如果可能的话,我将非常感激.
阅读C++ 11标准我无法完全理解以下语句的含义.例子非常受欢迎.
两组类型用于确定部分排序.对于涉及的每个模板,都有原始函数类型和转换后的函数类型.[注意:转换类型的创建在14.5.6.2中描述. - 结束注释]演绎过程使用变换后的类型作为参数模板,将另一个模板的原始类型用作参数模板.对于部分排序比较中涉及的每种类型,此过程完成两次:一次使用转换的模板-1作为参数模板,使用template-2作为参数模板,再次使用转换的模板-2作为参数模板和模板-1作为参数模板
- N3242 14.8.2.4.2
c++ templates partial-ordering c++11 template-argument-deduction
我有这个小的protobuf代码(简化,只包含必要的):
message ParamsMessage {
required int32 temperature = 1;
}
message MasterMessage {
enum Type { GETPARAMS = 1; SENDPARAMS = 2;}
required Type type = 1;
optional ParamsMessage paramsMessage = 2;
}
我现在以下列方式创建一个MasterMessage:
ParamsMessage * params = new ParamsMessage();
params->set_temperature(22);
MasterMessage master;
master.set_type(MasterMessage::SENDPARAMS);
master.set_allocated_paramsmessage(params);
问题是:我是否必须(在处理消息后)删除params消息,或者将protobuf删除给我？我在文档中找不到任何内容.
#include <iostream>
#include <array>
#include <vector>
template <typename T, typename SFINAE=void>
struct trait;
template <typename T>
struct trait<T, decltype(
std::declval<const T&>().begin(),
std::declval<const T&>().end(),
void()
)> {
static const char* name() { return "Container"; }
};
template <typename T, std::size_t N>
struct trait<std::array<T,N>> {
static const char* name() { return "std::array"; }
};
int main(int argc, char* argv[]) {
std::cout << trait<std::vector<int>>::name() << std::endl;
std::cout << trait<std::array<int,2>>::name() << std::endl;
}
我期待第三个模板比第二个模板更专业,但我得到了一个模糊的模板实例化.
有没有办法让第三个模板更专业？明确检查是否T是std::array在第二个模板不会为我工作.我正在写一个图书馆,希望用户能够定义他们自己的专业trait.第二个模板旨在成为没有更具体特征的容器的通用特化.
大多数std::string实现(包括GCC)使用小字符串优化.例如,有一个答案在讨论这个问题.
今天,我决定检查我编译的代码中的字符串在什么时候被移动到堆中.令我惊讶的是,我的测试代码似乎表明根本没有发生小的字符串优化!
码:
#include <iostream>
#include <string>
using std::cout;
using std::endl;
int main(int argc, char* argv[]) {
std::string s;
cout << "capacity: " << s.capacity() << endl;
cout << (void*)s.c_str() << " | " << s << endl;
for (int i=0; i<33; ++i) {
s += 'a';
cout << (void*)s.c_str() << " | " << s << endl;
}
}
输出g++ test.cc && ./a.out是
capacity: 0
0x7fe405f6afb8 |
0x7b0c38 | a
0x7b0c68 | aa …我已经实现了constexpr这样的数组:
template <typename T>
class const_array {
const T* p;
unsigned n;
public:
template <unsigned N>
constexpr const_array(const T(&a)[N]): p(a), n(N) { }
constexpr unsigned size() const { return n; }
};
int main(int argc, char* argv[]) {
// works
static_assert(const_array<double>{{1.,2.,3.}}.size() == 3);
// doesn't compile
constexpr const_array<double> a{{1.,2.,3.}};
static_assert(a.size() == 3);
}
为什么第一次static_assert编译,但初始化a失败？我正在使用gcc 6.2.0.我越来越
: In function 'int main(int, char**)':
: error: 'const_array<double>{((const double*)(&<anonymous>)), 3u}' is not a constant expression
constexpr const_array<double> a{{1.,2.,3.}}; …我正在尝试使用我的bash脚本中的环境变量来源文件,但它不起作用.
这是我的脚本(test.sh)的内容,位于~/scripts/test.sh.
#!/bin/bash
FILE_NAME=/tmp/source_file
touch $FILE_NAME
echo "export TEST=\"test\"" > $FILE_NAME
source $FILE_NAME
然后,我用alias在my ~/.bashrc.
alias testScript=~/scripts/test.sh
但是当我使用我的脚本时testScript,它没有设置环境变量.
令我惊讶的是,以下代码打印出来1.
std::cout << [](const char* arg){ return arg[0]=='s'; } << std::endl;
有人可以解释一下吗？
编译器（通常或特别）是否优化重复的函数调用？
例如，考虑这种情况。
struct foo {
member_type m;
return_type f() const; // returns by value
};
函数定义在一个翻译单元中
return_type foo::f() const {
/* do some computation using the value of m */
/* return by value */
}
重复的函数调用在另一个单元中
foo bar;
some_other_function_a(bar.f());
some_other_function_b(bar.f());
第二个翻译单元中的代码会转换成这个吗？
foo bar;
const return_type _tmp_bar_f = bar.f();
some_other_function_a(_tmp_bar_f);
some_other_function_b(_tmp_bar_f);
潜在地，计算f确实可能很昂贵，但返回的类型可能非常小（考虑一个返回 a 的数学函数double）。编译器会这样做吗？有没有他们做或不做的情况？您可以考虑这个问题的广义版本，而不仅仅是成员函数或没有参数的函数。
根据@BaummitAugen 的建议澄清：
我更感兴趣的是这里问题的理论方面，而不是人们是否可以依靠它来使现实世界的代码运行得更快。我对 Linux 上 x86_64 上的 GCC 尤其感兴趣。
我想写一个返回自己的lambda,所以我可以在现场多次调用它.但看起来lambda内部this不是指lambda而是指周围对象this,如果lambda是在成员函数内定义的话.
这是一个例子:
#include <iostream>
int main(int argc, char* argv[]) {
int a = 5;
[&](int b) {
std::cout << (a + b) << std::endl;
return *this;
}(4)(6);
}
有没有办法做一些类似的事情？