小编Mys*_*ial的帖子

当我的程序在gdb中被反汇编时,我可以看到buf的地址被压入堆栈,但是我没有看到格式字符串被压到它上面.这是什么原因？它是一个聪明的编译器优化？

我已经尝试编译一些printf语句的不同变体,看看我是否可以模仿"%s"字符串(或它的地址)没有被压入堆栈,但我无法做到.

这是程序代码:

int main(int argc, char **argv) {

    char buf[128];
    if(argc < 2) return 1;

    strcpy(buf, argv[1]);

    printf("%s\n", buf);

    return 0;
}

用gcc 4.5.2编译,32位linux

如何初始化const int二维向量:

Const int vector < vector < int > >  v ? 

v = {1 , 1 ; 1, 0}  ?

这是行不通的 .

这段代码给了我一个seg错误,但当我改变它时x--,--x它打印正确.

他们不一样????

int main()
{    
    myFunc(5); 
    return 0;
}

void myFunc (int x) {  
    if (x > 0) {
        myFunc(x--);
        printf("%d, ", x);
    }
    else
        return;
}

int main(int argc, char *argv[])
{
    uint64_t length = 0x4f56aa5d4b2d8a80;
    uint64_t new_length = 0;

    new_length = length + 119.000000;

    printf("new length  0x%"PRIx64"\n",new_length);

    new_length = length + 238.000000;

    printf("new length  0x%"PRIx64"\n",new_length);

    return 0;
}

用上面的代码.我将两个不同的double值添加到无符号的64位整数.我在两种情况下都得到完全相同的结果.程序的输出如下所示

$./a.out
new length  0x4f56aa5d4b2d8c00
new length  0x4f56aa5d4b2d8c00

我希望两个不同的结果,但事实并非case.I也尝试过的类型转换的uint64_t值的double作为

new_length = (double)length + 119.000000;

但这似乎也没有帮助.任何想法可能是什么问题？

我试图将一些代码从FANN Lib(用C语言编写的神经网络)移植到SSE2.但是SSE2的性能比普通代码差.使用我的SSE2实现运行一次运行需要5.50分钟而不需要5.20分钟.

SSE2怎么能比正常运行慢？可能是因为_mm_set_ps？我使用Apple LLVM编译器(XCode 4)编译代码(所有SSE扩展标志都打开,优化级别为-Os).

没有SSE2的代码

                neuron_sum +=
                fann_mult(weights[i], neurons[i].value) +
                fann_mult(weights[i + 1], neurons[i + 1].value) +
                fann_mult(weights[i + 2], neurons[i + 2].value) +
                fann_mult(weights[i + 3], neurons[i + 3].value);

SSE2代码

                __m128 a_line=_mm_loadu_ps(&weights[i]);
                __m128 b_line=_mm_set_ps(neurons[i+3].value,neurons[i+2].value,neurons[i+1].value,neurons[i].value);
                __m128 c_line=_mm_mul_ps(a_line, b_line);
                neuron_sum+=c_line[0]+c_line[1]+c_line[2]+c_line[3];

在Java中,字符串具有一个charAt()功能.

在C++中,该功能很简单 stringname[INDEX]

但是,如果我想在整数的某个索引处使用特定数字,该怎么办？

例如

int value = 9123;

假设我想使用索引0,这只是9.

有没有办法在整数中使用索引？

语言是Java.鉴于这种:

public static void main(String[] args) {
    Boolean b1 = true;
    Boolean b2 = true;
    int i1 = 1;

    if (b1 = true) //line 5
    if (b1 == true}  // line 6

我理解这b1 == true是一个等效测试,它会给出结果:true或false.然而,b1 = true对于我的理解是一个声明,除了在这种情况下,它应该只返回:b1 = true返回true,与==test 完全相同？

你能解释一下原因吗？谢谢!

这是我的代码,我需要澄清此代码的输出:

#include <stdio.h>
int main(void )
{
char name1[10] = "Rajan" , name2[10] = "Rajan" ;
char *name3 = "Chennai" , *name4 = "Chennai" ;
printf("\nAddress for name1 and name2 : %p and %p",name1,name2) ;
printf("\nAddress for name3 and name4 : %p and %p",name3,name4) ;
return 0 ;
}

这段代码的输出是

Address for name1 and name2 : 0x7fff9e6cbe10 and 0x7fff9e6cbe20
Address for name3 and name4 : 0x400760 and 0x400760

这里的值的地址name1和name2是不同的,因为我分配了两个不同的阵列.但在的情况下name3和name4,地址是相同的,为什么不一样？它不会创建不同的内存并为值分配名称Chennai？为什么它指向相同的内存？

字节顺序决定了字中字节的顺序。让我们考虑以下
内存系统：

所以这是一个字节可寻址的 32 位存储器。如果我将一个十六进制值移动'val = 0x56789A'到字地址为 0 的内存位置，那么对于大尾数法来说，它将如下所示：

对于小端来说是这样的：

但我们知道在寄存器中，值本身存储为“56789A”，因此如果我们有大端字节序，那么这没有问题，因为可以按正确的顺序加载值。
但如果是小尾数法，则必须颠倒顺序呢？在小尾数中，它将被加载为“9A7856”，这是错误的。
那么我们是否将它像这样存储在内存中，（即）对小端类型排序有不同的组织？例如 ：
现在我们可以将字地址位置“0”处的值加载到寄存器中以进行进一步的操作。这是一个可能的解决方案。
但现在这意味着字节顺序将取决于内存单元的排列，而不完全取决于处理器……这到底是如何工作的？
或者字节顺序是否完全不受内存架构影响而仅受处理器影响？那么最后字节顺序取决于处理器还是内存？

考虑这个C程序:

int main()
{
    puts("Hello world!");
    return 0;
}

编译并运行正常,据我所知,是合法的C89.但是,我不是百分百肯定的.使用clang在C99模式下编译告诉我implicit declaration of function 'puts' is invalid in C99(这使我认为C标准必须在C99中更改以使隐式函数声明非法,这是我正在尝试确认的).

隐含功能声明在C89中是合法的吗？(即使这样做是个坏主意(除非你在混淆的C代码挑战中))