此代码仅用于说明问题.
#include <functional>
struct MyCallBack {
void Fire() {
}
};
int main()
{
MyCallBack cb;
std::function<void(void)> func = std::bind(&MyCallBack::Fire, &cb);
}
使用valgrind进行的实验表明,分配的行在funclinux上使用gcc 7.1.1动态分配大约24个字节.
在真正的代码中,我有一些不同的结构,所有结构都void(void)存储了大约1000万个成员函数 std::function<void(void)>.
在做std::function<void(void)> func = std::bind(&MyCallBack::Fire, &cb);什么时,有什么方法可以避免内存被动态分配？(或以其他方式将这些成员函数分配给a std::function)
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/sctp.h>
#include <stdio.h>
#include <string.h>
int main(int argc,char **argv)
{
struct sockaddr_in remoteAddr;
int clientSock = socket(PF_INET,SOCK_SEQPACKET,IPPROTO_SCTP);
if(clientSock == -1) {
perror("socket");
return 1;
}
memset(&remoteAddr,0,sizeof remoteAddr);
remoteAddr.sin_family = AF_INET;
remoteAddr.sin_len = sizeof remoteAddr;
remoteAddr.sin_port = htons(5555);
remoteAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
sctp_assoc_t assoc_id = 0;
if(sctp_connectx(clientSock,(struct sockaddr*)&remoteAddr,1, &assoc_id)!= 0) {
perror("sctp_connectx");
return 1;
}
printf("Connected! Assoc ID %d\n",(int)assoc_id);
return 0;
}
运行时,此代码失败:
$ clang -Wall sctp_connect.c
$ ./a.out
sctp_connectx: Invalid argument
$ uname -rp …我有以下示例:
#include <iostream>
#include <functional>
struct Tmr {
typedef std::function<void(void)> Callback;
Callback cb;
Tmr(Callback cb_) :
cb( cb_ )
{
}
void timeout()
{
cb();
}
};
struct Obj {
struct Tmr t;
Obj() :
t( std::ref( *this ) )
{
}
void operator () ()
{
std::cout << __func__ << '\n';
}
};
int main(int argc, char *argv[])
{
Obj o;
o.t.timeout();
return 0;
}
运行正常,但最初我有以下构造函数Obj:
Obj() :
t( *this )
这导致运行时错误.我想这是因为只有对成员函数的引用存储在我的回调中,而不是调用成员的对象.
我不明白的是std::ref,当我这样做Obj() : …
我有这个例子:
#include <string>
#include <iostream>
class Test {
private:
std::string str;
public:
Test(std::string &&str_) :
str(str_)
{}
const std::string &GetStr()
{
return str;
}
};
int main(int argc, char *argv[])
{
std::string there("1234567890");
std::cout << "1. there: " << there << '\n';
Test t1(std::move(there));
std::cout << "2. there: " << there << '\n';
std::cout << "3. there: " << t1.GetStr() << '\n';
}
它给出了输出
$ ./a.out
1. there: 1234567890
2. there: 1234567890
3. there: 1234567890
这是在linux上使用gcc 5.1.1.虽然there字符串在移动后将保持有效但不确定的状态,但如果调用std :: …
当进程用完文件描述符时,accept()将失败并设置errno为EMFILE.但是,已接受的基础连接未关闭,因此似乎无法通知客户端应用程序代码无法处理连接.
问题是在用完文件描述符时接受TCP连接的正确行动是什么.
以下代码演示了我想学习如何最好地处理的问题(注意这只是用于演示问题/问题的示例代码,而不是生产代码)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
static void err(const char *str)
{
perror(str);
exit(1);
}
int main(int argc,char *argv[])
{
int serversocket;
struct sockaddr_in serv_addr;
serversocket = socket(AF_INET,SOCK_STREAM,0);
if(serversocket < 0)
err("socket()");
memset(&serv_addr,0,sizeof serv_addr);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr= INADDR_ANY;
serv_addr.sin_port = htons(6543);
if(bind(serversocket,(struct sockaddr*)&serv_addr,sizeof serv_addr) < 0)
err("bind()");
if(listen(serversocket,10) < 0)
err("listen()");
for(;;) {
struct sockaddr_storage client_addr;
socklen_t client_len = sizeof client_addr;
int clientfd;
clientfd …我从C API获取一个数组,我想将它复制到std :: array以便在我的C++代码中进一步使用.那么这样做的正确方法是什么？
I 2用于此,一个是:
struct Foo f; //struct from C api that has a uint8_t kasme[32] (and other things)
c_api_function(&f);
std::array<uint8_t, 32> a;
memcpy((void*)a.data(), f.kasme, a.size());
还有这个
class MyClass {
std::array<uint8_t, 32> kasme;
int type;
public:
MyClass(int type_, uint8_t *kasme_) : type(type_)
{
memcpy((void*)kasme.data(), kasme_, kasme.size());
}
...
}
...
MyClass k(kAlg1Type, f.kasme);
但这感觉相当笨重.有没有惯用的方法,这可能不涉及memcpy？对于MyClass`或许我最好使用构造函数获取一个std :: array进入成员但我无法弄清楚这样做的正确方法.？
我有一个简单的测试程序调用pthread_cond_broadcast.
与ld链接器链接时,显示:
情况1:
$ nm ld-test | grep cond_broadcast
U pthread_cond_broadcast@@GLIBC_2.3.2
与gold链接器链接时,它显示:
案例2:
$ nm gold-test | grep cond_broadcast
U pthread_cond_broadcast
pthread/libc包含几个带有不同版本符号的pthread_cond_broadcast符号,可能是因为ABI已被更改.
$ nm /lib64/libc.so.6 |grep cond_broadca
00000036b84f7d30 t __pthread_cond_broadcast
00000036b85278f0 t __pthread_cond_broadcast_2_0
00000036b84f7d30 T pthread_cond_broadcast@@GLIBC_2.3.2
00000036b85278f0 T pthread_cond_broadcast@GLIBC_2.2.5
$ nm /lib64/libpthread.so.0 |grep cond_broadcast
00000036b880bee0 t __pthread_cond_broadcast
00000036b880c250 t __pthread_cond_broadcast_2_0
00000036b880bee0 T pthread_cond_broadcast@@GLIBC_2.3.2
00000036b880c250 T pthread_cond_broadcast@GLIBC_2.2.5
所以问题是:
gold和老/正常之间的行为不同ld.pthread_cond_broadcast符号时,在案例2中正在运行时使用哪个pthread_cond_broadcast 符号.pthread_cond_broadcast的最新实现？最老的 ？这是使用gcc 4.9.2和binutils 2.24中的gold/ld链接器(作为Red Hat 的devtoolset-3的一部分.)
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
fn main() {
let f = File::open("test.txt").expect("Can't open");
let mut b = BufReader::new(f);
let v = b.fill_buf().unwrap();
println!("v: {:?}", v);
b.consume(v.len());
}
无法编译，错误是
error[E0499]: cannot borrow `b` as mutable more than once at a time
--> src/main.rs:10:5
|
7 | let v = b.fill_buf().unwrap();
| ------------ first mutable borrow occurs here
...
10 | b.consume(v.len());
| ^^^^^^^^^^-------^
| | |
| | first borrow later used here
| second mutable borrow occurs here
将最后一行更改为： …
我有这个代码，用于学习目的：
struct Fibonacci {
curr: u32,
next: u32,
}
impl Iterator for Fibonacci {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
let current = self.curr;
self.curr = self.next;
self.next = current + self.next;
Some(current)
}
}
impl Fibonacci {
fn new() -> Self {
Fibonacci { curr: 0, next: 1 }
}
fn current(&self) -> u32 {
self.curr
}
}
fn main() {
println!("The first four terms of the Fibonacci sequence are: ");
let fib = Fibonacci::new(); …