Tag: 指针

是否在C中获取无效指针的值未定义或实现定义的行为？

根据此，获取无效指针的值是C ++中的实现定义行为。 现在考虑以下C程序： #include #include int main(void) { int* p=(int*)malloc(sizeof(int)); *p=3; printf(“%d\n”,*p); printf(“%p\n”,(void*)p); free(p); printf(“%p\n”,(void*)p); // Is this undefined or implementation defined in behaviour C? } 但是C中的行为也一样吗？ 上述C程序的行为是否未定义或实现定义？ C99 / C11标准对此有何看法？ 请告诉我C99和C11的行为是否不同。

gcc说“从不兼容的指针类型分配

好的，所以我一直收到这个错误： $ gcc -Wall -g translate.c support.c scanner.c -o translate translate.c: In function ‘main’: translate.c:22:16: warning: assignment from incompatible pointer type [enabled by default] dictionary = createArray(count); ^ support.c: In function ‘readTokens’: support.c:66:18: warning: assignment from incompatible pointer type [enabled by default] a[count] = token; ^ 而且我不知道为什么。 这是我的主要function： #include #include #include #include “support.h” int main(int […]

指针间接是否比条件更昂贵？

指针间接（获取值）是否比条件更昂贵？ 我观察到大多数不错的编译器可以在不同程度上预先计算指针间接 – 可能删除大多数分支指令 – 但我感兴趣的是间接成本是否高于分支点的成本。生成的代码。 我希望如果指针引用的数据在运行时不在缓存中，可能会发生缓存刷新，但我没有任何数据可以支持。 有没有人有关于此事的可靠数据（或合理的意见）？ 编辑：几张海报指出，分支成本没有“一般情况”：芯片之间的差异很大。 如果您碰巧知道一个值得注意的情况，即分支比缓存间接更便宜（有或没有分支预测），请提及它。

在C中创建数组并将指针传递给所述数组以实现

我已经阅读了几篇与我关于C的问题相关的post。这确实帮助我减少了我的错误。 但是，我仍然遇到其他post无法解决的问题。 基本上，这就是我想要做的。 在main中定义一个数组。 我将指向此数组的指针传递给函数。 此函数将打开一个文件，解析该文件，并将该文件中的信息放入其指针传入的数组中。好吧，它失败了。 我得到的错误是： work.c:12: error: array type has incomplete element type work.c: In function ‘main’: work.c:20: error: type of formal parameter 1 is incomplete work.c: At top level: work.c:25: error: array type has incomplete element type 整个代码如下。 但我认为你只需要关注我如何定义我的数组和指针等等。 #include #include //Defining Preprocessed Functions char readFile(char array[][], int, int); //void displayStudentInfo(int*); //Implements […]

在C中，指针的地址可以是0吗？

我正在阅读Cracking the Coding访谈 （Q 1.2）一书中的问题解决方案。 目标是在C中实现一个反转空终止字符串的函数void revers(char* str) 。 解决方案代码如下所示： void reverse(char *str) { char* end=str; char tmp; if(str) { while(*end) { end++; } end–; //code to reverse } } 这里， str包含一个地址吧？ 如果str为0 ， if(str)只会评估为false ，对吗？ 所以我所说的是， str是否有可能包含地址0x0000 ，从而评估if(str)为false ？

字符串交换适用于char **但不适用于char *

在这个程序中，我交换了前两个名字 #include void swap(char **,char **); main() { char *name[4]={“amol”, “robin”, “shanu” }; swap(&name[0],&name[2]); printf(“%s %s”,name[0],name[2]); } void swap(char **x,char **y) { char *temp; temp=*x; *x=*y; *y=temp; } 这个程序运行得很完美但是当我使用function swap(char *,char *)它不会交换地址为什么？ 为什么我必须使用指针指针？

* y ++和++ * y之间的区别？

我对如何执行此代码感到困惑。 假设我们有 int x=30,*y,*z; y=&x; * y ++和++ * y之间有什么区别？ 以及该计划的产出是什么？ #include int main(){ int x=30,*y,*z; y=&x; z=y; *y++=*z++; x++; printf(“%d %d %d “,x,y,z); return 0; }

在64位拱上投射指向整数问题警告的指针

我正在编写一个使用导出符号open_exec的linux内核模块 struct file *open_exec(const char *name) 它返回一个指针，我可以检查IS_ERR宏的错误： if (IS_ERR(file)) return file; 在编译期间，我收到此警告： warning: return makes integer from pointer without a cast 这是因为我的函数返回一个整数。 如果我尝试施放它： return (int) file; 我没有在我的32位机器上收到警告，但我在我的64位机器上发出警告： warning: cast from pointer to integer of different size 这是因为int和指针的sizeof在32位上是相同的，但它们在64位机器上是不同的。 无论是否投射，代码似乎都有效。 我只是想摆脱警告。 如何正确地转换指向整数的指针并获得我期望的值，同时没有得到编译器警告？ 我期望的值本质上是linux内核代码库的include/asm-generic/errno-base.h中列出的整数。 由于我只是在IS_ERR()为真的情况下将指针看作是一个整数，我可以肯定它实际上只保存一个整数值。

为什么左侧的“取消引用”和“地址”运营商？

在C（以及一些其他类C语言）中，我们有2个一元运算符用于处理指针：解引用运算符（ * ）和’运算符地址’（ & ）。 它们是一元运算符，它引入了操作顺序的不确定性，例如： *ptr->field 要么 *arr[id] 操作的顺序由标准严格定义，但从人的角度来看，这是令人困惑的。 如果*运算符是一个正确的一元运算符，则顺序很明显，不需要额外的括号： ptr*->field vs ptr->field* 和 arr*[id] vs arr[id]* 因此，运营商为什么会离开一元而不是正确，这是有充分理由的。 我想到的一件事是类型的声明。 左操作符保持在类型名称附近（ char *a vs char a* ），但是有类型声明，已经破坏了这个规则，所以为什么要打扰（ char a[num] ， char (*a)(char)等） 。 显然，这种方法也有一些问题，比如 val*=2 对于val = val * 2或dereference并指定val* = 2这将是*=短手。 然而，这可以通过在解除引用的情况下在*和=令牌之间需要空白来容易地解决。 再一次，没有任何开创性的，因为有这样一个规则的先例（ – -a vs –a ）。 那么为什么他们离开而不是正确的运营商呢？ 编辑：我想指出，我问了这个问题，因为C的许多更奇怪的方面都有有趣的解释，为什么它们是这样的，就像->运算符或类型声明或索引的存在一样从0开始。依此类推。 原因可能不再有效，但我认为它们仍然很有趣。

指针数组与元素数组

今天早上我和同事就这个话题进行了讨论。 他说，将数组分配为指针数组总是更好，因为分别分配每个元素有更好的机会获得一个空闲的内存块。 有人这样想： // Consider n_elements as a dynamic value int n_elements = 10, i; int **ary = (int **) malloc(sizeof(int *) * n_elements); for(i = 0; i < n_elements; i++) { ary[i] = (int *) malloc(sizeof(int)); } 与他的方法相反，我认为分配元素数组更好，只是因为你会获得一个紧凑的内存块而不是遍布堆的一堆引用。 像这样的东西： int n_elements = 10; int *ary = (int *) malloc(sizeof(int) * n_elements); ary[0] = 100; […]