小编Mys*_*ial的帖子

我正在实现一个Matrix类,我重载了*和+运算符.我也有一个构造函数:

Matrix (int row, int col, const elemType &init_val) 

构造一个初始化的矩阵,在所有位置保存init_val.所以基于这个实现,我有我的测试程序:

 Matrix<int> mi4 = Matrix<int> (2, 2, 3) + Matrix<int> (2, 2, 1);

编译器给我以下错误:

testMatrix.cpp:41: error: ambiguous overload for ‘operator+’ in ‘Matrix<int>(2, 2, ((const int&)((const int*)(&3)))) + Matrix<int>(2, 2, ((const int&)((const int*)(&1))))’
Matrix.h:91: note: candidates are: Matrix<elemType> operator+(const Matrix<elemType>&, const Matrix<elemType>&) [with elemType = int]

我记得在C++标准库中,你可以在表达式中调用构造函数.我该如何实现呢？非常感谢!

我对C相对较新.在Kochan的"C语言编程"中,我目前正在使用if-else语句.我正在尝试编写一个基本的tic-tac-toe游戏,但我遇到了一些困难.一旦玩家放置了x或o,我不确定如何保存棋盘.这是我到目前为止的代码:

#include <stdio.h>

int main (void)
{
    int board = "_|_|_\n
                 _|_|_\n
                  | | \n";
    int player1, player2;

    printf ("Print %i", board)

    printf("Player 1, it's your move:")
    scanf("%i", player1)

    if(player1 == "upLeft")
        printf("x|_|_\n
                _|_|_\n
                _|_|_\n
etc.

我还是太初学者才能实现这个功能吗？

我通过创建 10 个桶成功编写了基数排序的 C++ 代码。对于这 10 个桶，我是这样创建的：

struct node{
    struct node* next;
    long value;
};

struct node*bucket[10];

for (int i=0; i<10; ++i) {  
    bucket[i] = (struct node *) malloc (1000000*sizeof(struct node));
}

做得很完美。

但现在我需要将存储桶的数量增加到 100000。我尝试修改这些存储桶的大小，如下所示：

struct node*bucket[100000];

for (int i=0; i<100000; ++i) {  
    bucket[i] = (struct node *) malloc (1000000*sizeof(struct node));
}

但这次我想我什至无法创建这些桶。我正在使用 Visual Studio 进行编码，这是用 C++ 编写的。编译器给了我这些警告：

：警告 C4305：“参数”：从“__int64”截断为“size_t”

：警告 C4309：“参数”：常量值截断

我上网查了一下，有人说这个数字太大了。这是我第一次处理链表中这么大的数字。我需要修改任何内容才能使此代码再次工作吗？

谢谢。任何想法和帮助我将不胜感激！

我有一个具有以下结构的代码.

#pragma omp parallel for
for( i = 0; i < N; i++ )
{
    .....
    index = get_index(...);
    array[index] = ...;
    .....
}

现在index每个线程的值都是唯一的(它永远不会为不同的线程重叠),但是当然OpenMP无法猜测这个,我想是使用同步对象来访问array.

我怎么能要求openmp不要使用同步对象,array并依赖我,这个index值对于不同的线程是唯一的.我试图放入array私人列表,但是因此出现了分段错误.

void test()
{

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

}

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

你好,我是新来的,用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的速度相同吗？

我正在使用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个).

我在C中构造函数的偏导数.该过程主要由大量小循环组成.每个循环负责填充矩阵的列.因为矩阵的大小很大,所以应该有效地编写代码.我对实施有很多计划,我不想深入了解细节.

我知道智能编译器会尝试自动利用缓存.但我想了解更多使用缓存和编写高效代码和高效循环的细节.如果提供一些资源或网站,我将不胜感激,因此我可以更多地了解如何在减少内存访问时间和利用优势方面编写有效代码.

我知道我的请求看起来很草率,但我不是电脑人.我做了一些研究但没有成功.所以,任何帮助表示赞赏.

谢谢

我有两个循环并行化

#pragma omp parallel for
  for (i = 0; i < ni; i++)
    for (j = 0; j < nj; j++) {
      C[i][j] = 0;
      for (k = 0; k < nk; ++k)
        C[i][j] += A[i][k] * B[k][j];
    }
#pragma omp parallel for
  for (i = 0; i < ni; i++)
    for (j = 0; j < nl; j++) {
      E[i][j] = 0;
      for (k = 0; k < nj; ++k)
        E[i][j] += C[i][k] * D[k][j];
    }

奇怪的是，即使使用大量线程，顺序执行也比上面的并行版本快得多。难道我做错了什么？请注意，所有数组都是全局的。这有区别吗？