我最近看到我的一位同事std::string用作缓冲区：
std::string receive_data(const Receiver& receiver) {
std::string buff;
int size = receiver.size();
if (size > 0) {
buff.resize(size);
const char* dst_ptr = buff.data();
const char* src_ptr = receiver.data();
memcpy((char*) dst_ptr, src_ptr, size);
}
return buff;
}
我猜这家伙想利用返回字符串的自动销毁功能，因此他不必担心释放分配的缓冲区。
这对我来说有点奇怪，因为根据cplusplus.com，该data()方法返回const char*指向由字符串内部管理的缓冲区的指针：
const char* data() const noexcept;
Memcpying到一个const char指针？AFAIK只要知道我们所做的事情就不会造成伤害，但是我错过了什么吗？这很危险吗？
我有两个结构定义如下:
struct EmptyStruct{
};
struct StructEmptyArr{
int arr[0];
};
int main(void){
printf("sizeof(EmptyStruct) = %ld\n", sizeof(EmptyStruct));
printf("sizeof(StructEmptyArr) = %ld\n", sizeof(StructEmptyArr));
return 0;
}
在Ubuntu 14.04,x64上用gcc(g ++)4.8.4编译.
输出(对于gcc和g ++):
sizeof(EmptyStruct) = 1
sizeof(StructEmptyArr) = 0
我能理解为什么sizeof(EmptyStruct)等于1但不能理解为什么sizeof(StructEmptyArr)等于0.为什么两者之间存在差异？
Hadoop中分割大小和块大小之间的关系是什么？正如我在阅读此,分割大小必须是块大小的n倍(n是一个整数且n> 0),这是正确的吗？分割大小和块大小之间有关系吗？
我在HBase上使用OpenTSDB(虚拟盒上的伪分布式Hadoop)以非常高的负载(~50,000记录/秒)发送数据.系统工作了一段时间,但突然下降了.我终止了OpenTSDB和HBase.不幸的是,我再也不能把它们搞砸了.每次我尝试运行HBase和OpenTSDB时,都会显示错误日志.在这里我列出了日志:
RegionServer的:
2015-07-01 18:15:30,752 INFO [sync.3] wal.FSHLog: Slow sync cost: 112 ms, current pipeline: [192.168.56.101:50010]
2015-07-01 18:15:41,277 INFO [regionserver/node1.vmcluster/192.168.56.101:16201.logRoller] wal.FSHLog: Rolled WAL /hbase/WALs/node1.vmcluster,16201,1435738612093/node1.vmcluster%2C16201%2C1435738612093.default.1435742101122 with entries=3841, filesize=123.61 MB; new WAL /hbase/WALs/node1.vmcluster,16201,1435738612093/node1.vmcluster%2C16201%2C1435738612093.default.1435742141109
2015-07-01 18:15:41,278 INFO [regionserver/node1.vmcluster/192.168.56.101:16201.logRoller] wal.FSHLog: Archiving hdfs://node1.vmcluster:9000/hbase/WALs/node1.vmcluster,16201,1435738612093/node1.vmcluster%2C16201%2C1435738612093.default.1435742061805 to hdfs://node1.vmcluster:9000/hbase/oldWALs/node1.vmcluster%2C16201%2C1435738612093.default.1435742061805
2015-07-01 18:15:42,249 INFO [MemStoreFlusher.0] regionserver.HRegion: Started memstore flush for tsdb,,1435740133573.1a692e2668a2b4a71aaf2805f9b00a72., current region memstore size 132.20 MB
2015-07-01 18:15:42,381 INFO [MemStoreFlusher.1] regionserver.HRegion: Started memstore flush for tsdb,,1435740133573.1a692e2668a2b4a71aaf2805f9b00a72., current region memstore size 133.09 MB
2015-07-01 18:15:42,382 WARN [MemStoreFlusher.1] regionserver.DefaultMemStore: Snapshot called again without …我面临一个问题:过程工厂的数据库.采样率为50 ms时,最多有50,000个传感器.所有测量值都需要存储至少3年,并且必须支持实时查询(即用户可以查看延迟小于1秒的历史数据).我最近阅读了一篇关于时间序列数据库的文章,现有很多选项:OpenTSDB,KairosDB,InfluxDB,......
我很困惑哪一个适合这个目的？任何人都知道这个请帮助我!
更新15.06.25
今天我运行一个基于OpenTSDB的测试.我使用Virtual Box创建了一个由3个CentOS x64 VM组成的集群(1个主服务器,2个从服务器).主机配置为8 GB RAM,核心i5.主VM配置为3 GB RAM,从站配置为1.5 GB RAM.我编写了一个python程序来向OpenTSDB发送数据,如下所示:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("192.168.10.55", 4242))
start_time = time.time()
start_epoch = 1434192418;
for x in range(0, 1000000):
curr_epoch = start_epoch + x
tag1 = "put TAG_1 %d 12.9 stt=good\n" % (curr_epoch)
tag2 = "put TAG_2 %d 12.9 stt=good\n" % (curr_epoch)
tag3 = "put TAG_3 %d 12.9 stt=good\n" % (curr_epoch)
tag4 = "put TAG_4 %d 12.9 stt=good\n" % (curr_epoch)
tag5 = "put TAG_5 %d 12.9 …我写了一个使用std :: queue的小程序
queue<double> the_queue;
for(int i = 0; i < 100; i++)
{
for(int j = 0; j < 5000; j++)
{
double d = 1.0 * (rand() % 1000);
the_queue.push(d);
}
}
printf("Done pushing\n");
while(!the_queue.empty())
{
the_queue.pop();
}
printf("Done popping\n");
我将2个断点放在printf("Done pushing\n");并且printf("Done popping\n");在命中断点时检查程序的内存使用情况(在任务管理器中显示).在Done pushing,内存使用量约为34 MB,但Done popping内存使用量仍为~34 MB.这让我感到惊讶!
为什么是这样？有没有办法克服这个问题？
我是C#编程的初学者.我现在正在研究strings,structs,value types和reference types.作为公认的答案,在这里和在这里,strings是具有存储在堆栈指针,而存储在堆的实际内容的引用类型.此外,如此处所述,structs是值类型.现在,我尝试练习structs并strings用一个小例子:
struct Person
{
public string name;
}
class Program
{
static void Main(string[] args)
{
Person person_1 = new Person();
person_1.name = "Person 1";
Person person_2 = person_1;
person_2.name = "Person 2";
Console.WriteLine(person_1.name);
Console.WriteLine(person_2.name);
}
}
上面的代码片段输出
Person 1
Person 2
这让我感到困惑.如果strings是引用类型并且structs是值类型,那么person_1.name和person_2.name应该指向堆上的相同空间区域,不应该是它们吗？
我正在制作一个小程序如下：
void reserve_file_space(char* file_path, size_t amount)
{
FILE* fp = fopen(file_path, "w+b");
if(!fp)
{
printf("could not create a new file\n");
return;
}
int fseek_ret = fseek(fp, amount, SEEK_SET);
if(fseek_ret != 0)
{
printf("could not seek to the desired position\n");
fclose(fp);
return;
}
char garbage = 1;
size_t ret = fwrite(&garbage, 1, 1, fp);
if(ret != 1)
{
printf("could not write the garbage character\n");
}
fclose(fp);
}
int main(int argc, char* argv[])
{
reserve_file_space("C:\\Users\\SysPart\\Desktop\\test.bin", 1 << 30);
return 0;
}
我的 …
我写了一个程序,将两个小文件压缩成一个更大的文件.我首先从输入文件读取数据,合并数据,并将输出写入临时文件.完成后,我将临时文件重命名为所需的文件名(位于磁盘上的同一分区中).这是伪代码:
FILE* fp_1 = fopen("file_1.dat", "r+b");
FILE* fp_2 = fopen("file_2.dat", "r+b");
FILE* fp_out = fopen("file_tmp.dat", "w+b");
// 1. Read data for the key in two files
const char* data_1 = ...;
const char* data_2 = ...;
// 2. Merge data, store in an allocated buffer
// 3. Write merged buffer to temp file
fwrite(temp_buff, estimated_size, 1, fp_out);
fflush(fp_out);
fclose(fp_1);
fclose(fp_2);
fclose(fp_out);
// Now rename temp file to desired file name
if(std::rename("file_tmp.dat", "file_out.dat") == 0)
{
std::remove("file_1.dat");
std::remove("file_2.dat");
}
我用两个每个5 MB的输入文件反复测试程序.有一次我通过拔掉电源线突然关闭系统.重新启动系统后,我检查了数据,发现输入文件已被删除,并且 …
我最近发现了C/C++的黑暗角落:typedef关键字不需要成为第一个单词就行了,并且知道下面所有看起来很奇怪 typedef的东西在C和C++中都是有效的,我感到很惊讶:
int typedef a;
short unsigned typedef b;
以上typedefs相当于:
typedef int a;
typedef short unsigned b;
并且,以下内容在C++中无效,但在C中有效:
typedef enum { c };
typedef;
typedef int;
typedef int short;
语言设计师在C和C++中留下这个黑暗角落的原因是什么？