小编Jea*_*nès的帖子

我有一个项目(一个库),它被细分为几个包含代码的目录.我想在项目的根目录中使用g ++搜索头文件,因此我可以避免跨多个源文件的相同头文件的不同包含路径.

主要是,该root/目录有子目录A/,B/并且C/,所有这些都.hpp和.cpp里面的文件.如果A中的某个源文件想包含file.hpp在B中,那么就必须这样做:#include "../B/file.hpp".对于C中的另一个源文件也是如此.但是,如果A本身具有需要文件的子目录file.hpp,那么它将是不一致的并且如果我决定移动文件会导致错误(因为包含路径将是"../../B/file.hpp").

此外,这还需要在其他项目中工作,这些项​​目位于其他项目之外root/.我已经知道有一个选项可以手动将我的所有头文件复制到默认搜索目录中,但我想按照我描述的方式执行此操作.

编辑:使用该库的所有程序必须仅使用g++ prog.cpp lib.a -o prog.这意味着永久设置g ++的包含路径!

如果我有一个使用线程运行的程序并fork()在基于 unix 的系统上调用，线程是否被复制？我知道当前进程的虚拟内存以 1:1 的比例复制到生成的新进程中。我知道线程在进程的虚拟内存中有自己的堆栈。因此，至少也应该复制线程堆栈。但是，我不知道不驻留在虚拟内存中的线程是否还有其他内容，因此不会被复制。如果没有，这两个进程是共享线程还是独立的副本？

我有一个模板类C,它具有类型的非类型但引用模板参数P:

class P {
public:
  int x;
  int y;
};

template <const P &x>
class C {
public:
  const int &f() { return x.x; }
};

我声明了一个类型的全局变量P:

P p = {33,44};

我还声明了一个返回引用的函数p:

constexpr const P &h() { return p; }

然后尝试在下面使用这些:

C<p> o;    // line 1
C<h()> oo; // line 2

当然我对第一次实例化没有问题,但第二次实例化没有问题.我的编译器抱怨:

error: non-type template argument does not refer to any declaration

为什么会这样？我无法在常规中找到反对它的论据.我不确定它是否与在默认模板参数中调用constexpr完全相同的问题,其中讨论是关于嵌套 instanciation的实例化点.这是一个类型问题,但哪一个？我的函数h()返回对定义良好的类型(const …

两个调用都是正确的：

Collectors.groupingBy((String s)->s.toLowerCase(),Collectors.counting());
Collectors.groupingBy((String s)->s.toLowerCase(Locale.ENGLISH),Collectors.counting());

从那以后，为什么下面一个是错误的：

Collectors.groupingBy(String::toLowerCase,Collectors.counting());

毕竟String::toLowerCase不能对应第二个……那为什么IntelliJ会Reference to 'toLowerCase' is ambiguous, both 'toLowerCase(Locale)' and 'toLowerCase()' match说呢？

String::toLowerCase必须明确解决(String s)->s.toLowerCase()还是我错过了什么？

当然，如果我为 IntelliJ 添加更多上下文，例如：

Collector<String,?,Map<String,Long>> c = Collectors.groupingBy(String::toLowerCase,Collectors.counting());

这是正确的，但是在 Java 10 var 推理类型上下文中这是错误的：

var c = Collectors.groupingBy(String::toLowerCase,Collectors.counting());

我知道编译器无法推断counting. 如果我写：

Collector<String,?,Long> counter = Collectors.counting();
var c = Collectors.groupingBy(String::toLowerCase,counter);

它是正确的。因此，为什么编译器不能推断出唯一可接受的形式？

- - - -编辑 - - - -

我交替使用 IntelliJ/编译器只是因为我首先使用 IntelliJ 并且报告的错误是：

Reference to 'toLowerCase' is ambiguous, both 'toLowerCase(Locale)' and 'toLowerCase()' match

编译器的错误更难以理解（但包含更多关于推理失败原因的提示），例如：

Demo.java:31: error: …

得到此错误:

致命错误:无法将NSNumber桥接到Float.问题是什么？

这是原始消息,它是float而不是string.

{\"name\":\"Tomas\",\"gender\":\"male\",\"probability\":0.99,\"count\":594}

我试图理解printfC中的一个简单案例是如何工作的.我写了以下程序:

#include "stdio.h"

int main(int argc, char const *argv[])
{
    printf("Test %s\n", argv[1]);
    return 0;
}

运行objdump在二元我注意到Test %s\n寓于.rodata

objdump -sj .rodata bin

bin:     file format elf64-x86-64

Contents of section .rodata:
 08e0 01000200 54657374 2025730a 00        ....Test %s..

如此格式化的打印似乎执行从rodata其他地方的其他模式复制.

在编译并运行它之后,stare ./bin rr我注意到brk在实际写入之前有一个系统调用.所以运行它

gdb catch syscall brk
gdb catch syscall write

显示在我的情况下,当前中断等于0x555555756000,但然后设置为0x555555777000.当write发生格式化的字符串时

x/s $rsi
0x555555756260: "Test rr\n"

位于"旧"和"新"休息之间.写入发生后,程序退出.

问题:为什么我们分配了这么多页面,为什么在写入系统调用后,中断没有返回到前一个页面？是否有任何理由使用brk而不是mmap …

以下是一些尝试使用OOB(紧急)数据的基本代码.我的问题是,如果客户端是C语言或Java语言,则服务器部分的行为不一样.很可能,你可能认为在客户端都有些棘手但如果我使用C服务器(为了更好地控制OOB),那么两个客户端的行为完全相同,无论我的服务器端OOB控制如何.

首先是服务器(Java)部分:

Socket s = ss.accept();
s.shutdownOutput();
s.setOOBInline(true);
InputStream is = s.getInputStream();
for (;;) {
  byte []d = new byte[3];
  int l = is.read(d);
  if (l==-1) break;
  for (int i=0; i<l; i++) System.out.print((char)d[i]);
  System.out.println();
  Thread.sleep(2000);
}

然后客户端(Java)部分:

Socket s = new Socket("localhost",61234);
s.shutdownInput();
OutputStream os = s.getOutputStream();
byte []n = new byte[10];
for (int i=0; i<n.length; i++) n[i] = (byte)('A'+i);
byte m = (byte)('0');   
os.write(n);
System.out.println("normal sent");
s.sendUrgentData(m);
System.out.println("OOB sent");
os.write('Z');
System.out.println("normal sent");

然后是备用客户端(C)部分:

s = socket(PF_INET,SOCK_STREAM,0);
bzero(&a,sizeof(a));
a.sin_family = …

我试图找到很多,如果只有一个类在多重继承中变成虚拟的话？在这种情况下,构造函数调用的行为对我来说并不清楚.比如说代码 -

#include<iostream>
using namespace std;
class grand{
public:
    grand(){cout<<"grandfather"<<endl;}
};
class parent1:virtual public grand{   //virtual used only here
public:
    parent1(){cout<<"parent1 "<<endl;}
};
class parent2: public  grand{
public:
    parent2(){cout<<"parent2"<<endl;}
};
class child:public parent1,public parent2{
public:
    child(){cout<<"child"<<endl;}
};
int main()  {
    child s;
    return 0;
}

此代码的输出如下

grandfather
parent1 
grandfather
parent2
child

但是在上面的代码中如果我们改变这个

class parent1:virtual public grand{
public:
    parent1(){cout<<"parent1 "<<endl;}
};
class parent2: public  grand{
public:
    parent2(){cout<<"parent2"<<endl;}
};

对此

class parent1:public grand{   //virtual removed from here
public:
    parent1(){cout<<"parent1 "<<endl;} …

在[7.1.4库函数的使用]中,我读到:

标题中声明的任何函数可以另外实现为标题中定义的函数式宏...

和

任何实现为宏的库函数的调用都应扩展为仅对其每个参数进行一次计算的代码...

那么getc,[7.21.7.5 getc函数]:

getc函数等效于fgetc,除非它是作为宏实现的,它可能会多次评估流,因此参数永远不应该是带有副作用的表达式.

定义是getc:

• 与库函数定义相矛盾？
• 反过来？
• 这是标准中的不连贯吗？
• 或者这是否意味着如果getc单独实现(似乎不符合但是？)作为宏,它可以两次评估其参数？

我读了这个 api doc Stream api，它说（一个段落中的三个句子）

“如果中间操作在呈现无限输入时可能会产生有限流，则它是短路的。”

“如果终端操作在无限输入时可能在有限时间内终止，则它是短路的。”

“在管道中进行短路操作是无限流处理在有限时间内正常终止的必要条件，但不是充分条件。”

1. 我不明白为什么中间和终端操作在出现无限输入时会短路。

2. 我也不明白第三句话为什么短路是必要的，但处理无限流在有限时间内正常终止的条件不充分。

如果有人通过代码示例帮助我理解，那就太好了。

我对短路的了解就像

例如，if( a && b ) { ... }如果 a 为假，则不必检查 b。