小编Deb*_*ish的帖子

#include <stdio.h>

int main() {
    int i,n;
    int a = 123456789;

    void *v = &a;

    unsigned char *c = (unsigned char*)v;

    for(i=0;i< sizeof a;i++) {
        printf("%u  ",*(c+i));
    }

    char *cc = (char*)v;
    printf("\n %d", *(cc+1));

    char *ccc = (char*)v;
    printf("\n %u \n", *(ccc+1));

}

该程序在我的32位Ubuntu机器上生成以下输出.

21  205  91  7  
-51
4294967245

前两行输出我能理解=>

• 第1行:在内存中存储字节的顺序.
• 第二行:第二个字节值的有符号值(2的补码).
• 第3行:为什么这么大的价值？

请解释最后一行输出.为什么添加三个1的字节,因为(11111111111111111111111111001101) = 4294967245.

我试图了解grpc c ++异步模型流程。本文（链接）已经解释了我的许多疑问。这是grpc_asycn_server的代码 。为了了解CompletionQueue何时获取请求，我添加了一些打印语句，如下所示：

首先在HandleRpcs（）函数内部。

void HandleRpcs() {
    // Spawn a new CallData instance to serve new clients.
    new CallData(&service_, cq_.get());
    void* tag;  // uniquely identifies a request.
    bool ok;
    int i = 0;
    while (true) {
      std::cout << i << std::endl; ///////////////////////////////
      // Block waiting to read the next event from the completion queue. The
      // event is uniquely identified by its tag, which in this case is the
      // memory address of a CallData …

    #include <stdio.h>
    #include <string.h>
    int main() {

    char *s[] = {"cricket","tennis","football"};

    printf(" String are: \n\n");
    printf("  %s \n", *(s));
    printf("  %s \n", *(s+1));
    printf("  %s \n", *(s+2));
    printf("  \n\n");

    printf("  Starting locations of the string are: \n\n");

    printf("  %d\n",*(s));
    printf("  %d\n",*(s+1));
    printf("  %d\n",*(s+2));
    printf("  \n\n");

    return 0;
}

OUTPUT:

String are: 

cricket 
tennis 
football 


Starting locations of the string are: 

134514112
134514120
134514127

s是一个字符指针数组.s有三个元素,每个元素都存储字符串literal的起始地址.s [0]是一个指向"cricket"起始地址的指针.等等..

我的问题是:

通过观察这些地址,我们可以看到第二个字符串存储在第一个字符串的空字符之后.所有三个字符串都以顺序形式存储.这总是如此吗？

我Ubuntu18.04在 kvm-qemu 虚拟化设置中安装了桌面，它正在工作。我发现虚拟机的 virt-manager 设置中有一个直接内核启动选项。我想使用主机上的 gdb 调试内核。

请帮忙找到kernel路径和initrd.img文件路径。

内核路径与arch/x86/boot/bzImage？. 是否可以将initrd.imgguest ( /boot/ directory) 内的文件复制到主机上？

谢谢！

我面临以下问题.我有一个受保护的数据结构a map中<ID , Object>.只有一个地图数据结构和多个线程可能想要使用的地图set和get值ID.在Object如图所示的以下示例代码可被嵌套.

#include <iostream>
#include <map>
#include <algorithm>
#include <mutex>
using namespace std;
struct C {
    int r;
    char s;
};
struct B {
    int p;
    char q;
    C c;
};
struct A {
    int x;
    int y;
    B b;
    char z;
};
/*
    A
    L__ x
    |
    L__ y
    |
    L__ B
        L__p
        |
        L__q
        |
        L__C
            L__r
            |
            L__s

*/
/*  the follwing is …

我有一个 Go RPC 服务器来服务客户端请求。客户端向服务器请求工作（或任务），服务器将任务分配给客户端。服务器期望工作人员（或客户端）在限定时间内完成任何任务。因此服务器端需要有超时事件回调机制。

这是我到目前为止所尝试的。

func (l *Listener) RequestHandler(request string, reply string) error {
    // some other work
    // ....
    _timer := time.NewTimer(time.Second * 5) // timer for 2 seconds
    go func() {
        // simulates a client not replying case, with timeout of 2 sec
        y := <-_timer.C
        fmt.Println("TimeOut for client")
        // revert state changes becasue of client fail
    }()

    // set reply
    // update some states
    return nil
}

在上面的代码片段中，对于来自工作人员（或客户端）的每个请求，服务器端的处理程序都会启动一个计时器和一个 goroutine。Goroutine 在向客户端发送回复之前恢复处理程序函数所做的更改。

有没有办法创建“一组计时器”并阻止等待“一组计时器”？此外，每当计时器到期时，阻塞等待就会唤醒并为我们提供计时器句柄。根据计时器类型，我们可以在运行时执行不同的到期处理函数。

我正在尝试在 Go 中实现类似的机制，我们可以在 C++ 中使用timerfd …

我正在学习使用c++ lock_guard. 网上资源说我们不需要unlock手动，其次在出现异常的情况下mutex会自动释放，以便其他线程可以继续。

我正在尝试为第二种情况找到一个例子。基本上，当一个线程出现异常然后另一个线程应该继续时，我试图找到用例。

std::mutex m;
void f1() {
    lock_guard<std::mutex> lock(m);
    // some task  that may raise exception
}
void f2() {
    lock_guard<std::mutex> lock(m);
    // some other task
}
int main() {
    std::thread T1(f1);   
    T1.detach();

    std::thread T2(f2);   
    T2.join();
}

我在里面尝试了除以零的算术f1。但它使整个程序崩溃。然后我尝试在内部分配一个非常大的内存（例如new int[100000000000]）f1。然后整个程序也崩溃了bad_alloc。

std::mutex m;
int a,b;
void f1() {
    lock_guard<std::mutex> lock(m);
    a = 1;
    int * ptr = new int[10000000000]; // too large
    b = 2;
} …