小编Mys*_*ial的帖子

void test()
{

    unsigned char c;
    c = (~0)>>1 ;  
    printf("c is %u\n",c); 

}

它打印255.我期待127,因为我期望在右移后最左边的位设置为0.这是因为我的编译器正在进行右旋转吗？

此代码不会使代码更快地计算4个和.相反,它甚至需要更多时间.此外输出不是预期的.

#include <stdio.h>
#include <omp.h>
int main()
{
    int i,j,k,l;
    int sum = 0,sum1 = 0,sum2 = 0,sum3 = 0;
    #pragma omp parallel
    {
        #pragma omp sections
        {
            #pragma omp section
            {
                printf("%d",omp_get_thread_num());
                for(i = 0; i < 500000000; i++) sum = sum + 1;
            }
            #pragma omp section
            {
                printf("%d",omp_get_thread_num());
                for(i = 0; i < 500000000; i++) sum1 = sum1 + 1;
            }
            #pragma omp section
            {
                printf("%d",omp_get_thread_num());
                for(i = 0; i < 500000000; i++) sum2 = sum2 + …

当我编译我正在编写的程序时,我得到:

'class'之前的预期初始化程序

我的Class.h文件中的错误.我查找了互联网上的错误消息,但找不到确切的错误,虽然类似的错误似乎是由于缺少分号引起的,但我不明白为什么我需要一个.这是错误指向的代码,我之前没有其他函数或类.

class Account
{
    public:
    double dAccountBalance;

    double dAccountChange(double dChange);
};

在Class.cpp文件double dAccountChange(double dChange)中定义了函数.我不认为这是错误的来源,但这是代码;

double Account::dAccountChange(double dChange)
{
    dAccountBalance += dChange;

    return 0.0;
}

当我将Class.h中的代码更改为这样时,

;
class Account
{
    public:
    double dAccountBalance;

    double dAccountChange(double dChange);
};

它不会生成错误消息,但我无法解决为什么我之前需要分号作为我之前的唯一代码是以下预处理器行.

#ifndef CLASS_H_INCLUDED
#define CLASS_H_INCLUDED

有关错误产生原因的任何想法？

我收到了以下与以下问题相关的问题sizeof():

class C
{
public:
    C();
    virtual ~C();

    unsigned char _member0 s[4];
    static long _member1 d;
}

int main()
{
    C vc;
    cout << sizeof(vc);
}

有人可以解释sizeof()在这种情况下如何评估函数？

#include<stdio.h>
int main(){
    int a[5] = {0,1,2,3,4};
    int * ptr;
    ptr =(int *) &a;
    printf("\n&a:%u,&a[0]:%u,ptr:%u\n",&a,&a[0],ptr);
    ptr = (int*)(&a+1);
    printf("\n&a:%u,&a[0]:%u,ptr:%u\n",&a,&a[0],ptr);
    ptr = (int*)(&a);
    ptr = (int*)(&a[0]+4);
    printf("\n&a:%u,&a[0]:%u,ptr:%u,*ptr:%d\n",&a,&a[0],ptr,*ptr);
    return 0;
}

O/P:

&a:3213284540,&a[0]:3213284540,ptr:3213284540

&a:3213284540,&a[0]:3213284540,ptr:3213284560

&a:3213284540,&a[0]:3213284540,ptr:3213284556,*ptr:4

在上面的代码&a和&a[0]给出相同的地址3213284540.但添加的两种情况1给出了不同的地址.

&a[0]+1 => 3213284540 + 4     = 3213284544   [The value stored in this address is '1']
&a+1    => 3213284540 + (5*4) = 3213284560   [Goes Out of bounds of the array] 

&a+1 is equivalent to sizeof(array)+1. 

但是编译器如何解释这个&a[0]+1和&a+1 …

你好,我是新来的,用C语言编程.我不想问一些你可能认为简单的事情,但我已经问过我的同学,甚至我的编程老师看看他们是否能找到错误,但直到今天他们找不到它(他们).

但首先让我描述我所知道的,它说:

"运行时检查失败#2 - 堆栈变量"d" (有时m和其他y)已损坏".

我完成了我的工作试图调试它,但问题始终显示在最后一个代码行(主体),所以我找不到问题的确切位置,这里我附上代码,如果我附上代码,我会很高兴,如果你找到问题并解释我之所以得到它(不再重复同样的错误)= D.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* Type Declaration */
#define true 1
#define false 0
typedef char boolean;

/* Functions declaration */

boolean test( short int d, short int m, long int y );
boolean nextday( short int d, short int m , long int y );

int main( void )
{
    /* Variables initialization */
    short int d = 0, m = 0; 
    long int y = 0;

    do …

在我的英特尔x86奔腾手册中,它表示ADD和SAL/SHR之间的转换需要1/3时钟,而JMP和MOV需要1个时钟.这是否真的是一堆添加和移位比一堆mov快3倍？

我想我更加困惑,因为网上显示"延迟"的表格显示"Pentium M"并且没有时间是1/3,尽管有几个是1/2.这是因为我的书很旧而且新的Pentiums班次与JMP的速度相同吗？

我对虚函数有一些疑问,或者我们可以说运行时多态性.据我说,我假设它的工作方式如下,

1. 将为每个具有至少一个虚拟成员函数的类创建虚拟表(V表).我相信这是静态表,因此它是为每个类创建的,而不是为每个对象创建的.如果我错了,请在此纠正我.

2. 该V表具有虚函数的地址.如果该类有4个虚函数,那么该表有4个条目指向相应的4个函数.

3. 编译器将添加一个虚拟指针(V-Ptr)作为该类的隐藏成员.该虚拟指针将指向虚拟表中的起始地址.

假设我有这样的程序,

class Base
{
    virtual void F1();
    virtual void F2();
    virtual void F3();
    virtual void F4();
}
class Der1 : public Base  //Overrides only first 2 functions of Base class
{
    void F1(); //Overrides Base::F1()
    void F2(); //Overrides Base::F2()
}
class Der2 : public Base  //Overrides remaining functions of Base class
{
    void F3(); //Overrides Base::F3()
    void F4(); //Overrides Base::F4()
}
int main()
{
    Base* p1 = new Der1; //Believe Vtable will populated in compile time …

我正在使用PAPI高级API检查循环通过数组的简单程序中的TLB未命中,但看到的数字大于预期.

在其他简单的测试用例中,结果似乎非常合理,这使我认为结果是真实的,额外的遗漏是由硬件预取或类似的.

任何人都可以解释这些数字或指出我使用PAPI时出现的错误吗？

int events[] = {PAPI_TLB_TL};
long long values[1];
char * databuf = (char *) malloc(4096 * 32);

if (PAPI_start_counters(events, 1) != PAPI_OK) exit(-1);
if (PAPI_read_counters(values, 1) != PAPI_OK) exit(-1); //Zeros the counters

for(int i=0; i < 32; ++i){
    databuf[4096 * i] = 'a';
}

if (PAPI_read_counters(values, 1) != PAPI_OK) exit(-1); //Extracts the counters

printf("%llu\n", values[0]);

我期望打印的数字在32或至少一些倍数的区域内,但始终得到93或更高的结果(不是始终高于96,即每次迭代不仅仅是3次未命中).我正在运行固定到核心,没有别的东西(除了计时器中断).

我在Nehalem并没有使用大页面,因此DTLB中有64个条目(L2中为512个).

ISO/IEC 14882:2011(C++ 11)第1.10.11节定义了评估之间的"线程之间发生的关系",它与第1.10.12节中"之前发生"关系的唯一区别在于A发生在B之前A在B之前排序,但这对于B之前的线程间发生是不够的.为什么"之间的线程发生"重要到足以保证单独的定义？

第1.10.11节中的注释表明"之前发生的线程间"不允许评估的唯一关系是"之前"排序的部分

允许"之前发生的线程间"被传递关闭

那是什么意思？我知道什么是传递闭包,我知道一个集合在一些操作上关闭意味着什么,但我从来没有听说过"过渡性关闭",Google和上下文都让我失望.