小编Ric*_*ich的帖子

通过阅读在网上的职位相关的size_t和ptrdiff_t,我想确认以下内容:

1. 如果一个数组的最大大小小于1/2*(max number represent-able by size_t),我可以安全地使用ptrdiff_t并检查指向同一个对象的两个指针之间的相对距离吗？(因为我在谈论数组,"指向同一个对象的指针"意味着"指向同一个数组的指针") .

2. 如果我想声明一个可以表示来自另一个指针的偏移量的变量,我最好将其声明为类型ptrdiff_t？

3. 如何输出类型size_t和ptrdiff_tC和C++中的变量？以下是否正确:size_t类型的变量的跨平台格式字符串？

4. 是OR的uintptr_t另一个名称size_t它应该作为一个单独的类型使用size_t？

5. 是ssize_t和OR的intptr_t另一个名称ptrdiff_t必须以不同的方式使用？

我开始在Ubuntu上使用gcc.我在使用别人的代码时发现了这些类型.

ADDed:我确实希望能够使用负补偿.使用uintptr_t和任何差异intptr_t？

#include <iostream> 

int C; 

class C { 
  private: 
    int i[2]; 
  public: 
    static int f() { 
        return sizeof(C); 
    } 
}; 

int f() 
{ 
    return sizeof(C); // why the C can't be the class type C.
} 

int main() 
{ 
   std::cout << "C::f() = " <<C::f() << "," 
             << " ::f() = " <<::f() << std::endl; 
} 

上面的代码返回: C::f() = 8, ::f() = 4

我的问题是为什么C全局函数中的标识符f解析为int具有名称C 的类型的对象,而不是类类型C？是否sizeof有特定的名称查找规则？

结论:根据我在/sf/answers/42873351/中的内容,通过函数/对象/枚举器名称隐藏类名是为了兼容C的问题.为了避免这种无意的隐藏,应该typedef是类强制编译错误.

从这个链接,它说

对象,引用,函数(包括函数模板特化)和表达式都有一个名为type的属性

所以给出以下内容:

int &&rf_int = 10;

我可以说变量rf_int是对int的复合类型rvalue引用.

但在谈论价值类别时,它具体说明了这一点

每个表达式都有一些非引用类型

和

每个C++表达式(具有操作数,文字,变量名等的运算符)

基于以上两个语句,rf_int可以视为表达式和表达式具有非引用类型.

现在我真的很困惑.是否rf_int有引用类型？在谈论名称的类型时,我们是否必须提供上下文,无论是变量还是表达式？

更具体地说,当在函数调用中使用变量名时:

SomeFunc(rf_int);

是rf_int目前被认为是一个表达式(因此它是与int类型左值),或者一个变量(因此它与类型右值参考左值为int)？

编辑:这里的评论让我想知道这个问题.

#include<iostream>
#include<thread>
using namespace std;

void f1(double& ret) {
   ret=5.;
}

int main() {
   double ret=0.;
   thread t1(f1, ret);
   t1.join();
   cout << "ret=" << ret << endl;
}

上面的代码无法编译,并出现以下错误消息:

g++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
In file included from /usr/local/include/c++/5.3.0/thread:39:0,
                 from main.cpp:2:
/usr/local/include/c++/5.3.0/functional: In instantiation of 'struct std::_Bind_simple<void (*(double))(double&)>':
/usr/local/include/c++/5.3.0/thread:137:59:   required from 'std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = void (&)(double&); _Args = {double&}]'
main.cpp:11:21:   required from here
/usr/local/include/c++/5.3.0/functional:1505:61: error: no type named 'type' in 'class …

经过几个小时的谷歌搜索,我决定放弃并问你专家.我正试图在我的64 Ubuntu 11.10中构建一个32位应用程序(xgap,如果有兴趣的话).我在makefile中添加了CFLAGS = -m32和LDFLAGS = -L/usr/lib32.这些对象内置为32位精细.最后一步是将X窗口的所有对象和库链接到这个可执行文件--- xgap中.不知怎的,它一直给我这个错误:

gcc -o xgap xcmds.o utils.o gapgraph.o gaptext.o pty.o popdial.o xgap.o selfile.o   -L/usr/lib32 -lXaw -lXmu -lXt -lXext -lX11  -lSM -lICE

/usr/bin/ld: skipping incompatible /usr/lib32/libXmu.so when searching for -lXmu
...

/usr/bin/ld: i386 architecture of input file `xcmds.o' is incompatible with i386:x86-64 output
...

我已经安装了ia32-libs和mutilib支持.我想我只需要强制链接器生成i386输出.我试图在我的gcc命令中放入两个ld标志,如上所示:-melf_i386和-oformat elf32-i386.但是,gcc不再搜索/ usr/lib32中的32位库.我想知道我是否需要按固定顺序放置这些标志？

感谢您的任何想法和帮助!

编辑:当我在我的上一个gcc命令(我相信的链接阶段)中添加-m32标志时,即使我有-L/usr/lib32标志,gcc也不再搜索/ usr/lib32(真的奇怪...)并生成以下错误:

/usr/bin/ld: skipping incompatible /usr/lib/gcc/x86_64-linux-gnu/4.6.1/../../../libXaw.so when searching for -lXaw …

我理解,当我们写delete []一个由相应的指针创建的指针时new [],程序将查找数组上的计费信息并找出数组的元素大小(计数器).然后程序在每个元素上调用元素的析构函数.最后,内存(什么内存??)由一个名为的函数释放operator delete.

我所问的是是否delete[]会回收整个内存,通过分配的new[]表达,在一个镜头,因为该信息(总内存量),可之后的所有元素被破坏,还是会陆续解除分配由数组元素所占用的内存它已经调用了析构函数？

问一个相关的后续问题删除(非数组形式)是否知道新的或新的[]分配的内存总量

C++私有和受保护的虚方法,有没有使用公共虚方法的正当理由？正在讨论非虚拟接口(NVI)和非公共虚拟功能及其共生关系.Scott Meyers也在Effective C++中说过

有时虚拟功能甚至必须是公开的,但是NVI惯用法无法真正应用.

我没有看到为什么NVI 要求特定于实现的虚拟功能是非公开的？从Herb Sutter的文章Virtuality来看,它是一个很好的做法,例如,将公共(客户端)接口与实现细节(非公共接口)分开是很好的.我想知道的是,如果有任何语言功能我错过了语义上会阻止NVI被应用,如果这些虚拟功能被公开？

例如:

class Engine
{
public:
    void SetState( int var, bool val );
    {   SetStateBool( int var, bool val ); }

    void SetState( int var, int val );
    {   SetStateInt( int var, int val ); }
private:
    virtual void SetStateBool(int var, bool val ) = 0;    
    virtual void SetStateInt(int var, int val ) = 0;    
};

如果我把带来哪些影响SetStateBool,并SetStateInt在类定义的公共部分？

const int num = 16;
struct inputs{
       double X1[num];
       double X2[num];
};

给我一个错误:

错误:在文件范围内修改了'X1'

"X2"也是如此.

但是我记得上面的C++很好,上面说的很好(我可能会误认为是C++).

任何人都可以为我澄清一下吗？

#include <iostream>
using namespace std;

int main() {
    int &&rfint = 10;
    int &l = rfint;
    std::cout << l << std::endl;
    std::cout << ++l << std::endl;
    std::cout << &l << std::endl;
    return 0;
}

使用上述构造，我可以10通过非常量左值引用直接操作prvalue l。我什至可以接受prvalue的地址。这是如何运作的？与延长寿命有关吗？

我有一个大概的想法,一个进程可以在ready_queueCPU选择候选者下一个运行的地方.还有一些进程等待(广泛地说)事件的其他队列.我很久以前从OS课程中知道IO和中断有等待队列.我的问题是:

1. 进程可以等待很多事件.是否有与每个此类事件对应的等待队列？

2. 这些等待队列是动态创建/销毁的吗？如果是这样,哪个内核模块负责管理这些队列？调度程序？是否有任何预定义的队列始终存在？

3. 为了最终从等待队列中获得等待进程,内核是否有从每个实际事件(硬件或软件)映射到等待队列的方法,然后删除该队列上的所有进程？如果是这样,内核采用了什么机制？

举个例子:

....
pid = fork();
if (pid == 0) { // child process
    // Do something for a second;
}
else { // parent process
    wait(NULL);
    printf("Child completed.");
}
....

wait(NULL)是一个阻塞系统调用.我想知道父进程经历的剩余旅程.我对故事情节的看法如下:如果我错过关键步骤或者我完全错了,请纠正我:

1. 通过libc运行时设置正常的系统.现在父进程处于内核模式,准备执行wait()syscall中的任何内容.

2. wait(NULL) 创建一个等待队列,内核稍后可以在其中找到此队列.

3. wait(NULL) 将父进程放到此队列上,在某个映射中创建一个条目,说明"如果我(内核)收到软件中断,信号或任何表明子进程已完成的内容,则调度程序应该查看此等待队列".

4. 子进程完成,内核以某种方式注意到了这个事实.内核上下文切换到调度程序,调度程序在映射中查找以查找父进程所在的等待队列.

5. 调度程序将父进程移动到就绪队列,发挥其魔力,稍后最终选择父进程运行.

6. 父进程仍处于内核模式,在wait(NULL)syscall中.现在,其余系统调用的主要工作是退出内核模式并最终将父进程返回到用户区.

7. 该过程继续其下一条指令的行程,并可能稍后等待其他等待队列,直到它完成.

PS:我希望了解操作系统内核的内部工作原理,进程在内核中经历的阶段以及内核如何交互和操作这些进程.我确实知道wait()Syscall API的语义和契约,这不是我想从这个问题中知道的.