标签: pointers

我正在尝试从函数参数返回数据指针:

bool dosomething(char *data){
    int datasize = 100;
    data = (char *)malloc(datasize);
    // here data address = 10968998
    return 1;
}

但是当我按以下方式调用函数时,数据地址变为零:

char *data = NULL;
if(dosomething(data)){
    // here data address = 0 ! (should be 10968998)
}

我究竟做错了什么？

嗨,我确信这一定是一个常见的问题,但是当我搜索它时,我找不到答案.我的问题主要涉及两个方面.我想比较他们的地址,并确定一个是否比另一个大.我希望在比较期间所有地址都是无符号的.这是真的,它在C89,C99和C++之间有所不同吗？当我用gcc编译时,比较是无符号的.

如果我有两个指针,我正在比较这样:

char *a = (char *) 0x80000000; //-2147483648 or 2147483648 ?  
char *b = (char *) 0x1; 

然后a更大.这是由标准保证的吗？

编辑以更新我想要做的事情.我有一种情况,我想确定如果有算术错误,它不会导致指针超出界限.现在我有数组的起始地址和结束地址.如果出现错误并且指针计算错误,并且在数组内存的有效地址之外,我想确保没有发生访问冲突.我相信我可以通过比较另一个函数返回的可疑指针,并确定它是否在数组的可接受范围内来防止这种情况.负面和正面地址的问题与我是否可以进行比较有关,正如我在原始问题中所讨论的那样.

到目前为止,我很欣赏答案.基于我的编辑,你会说我正在做的是gcc和msvc中未定义的行为吗？这是一个仅在Microsoft Windows上运行的程序.

这是一个简单的例子:

char letters[26];  
char *do_not_read = &letters[26];  
char *suspect = somefunction_i_dont_control(letters,26);  
if( (suspect >= letters) && (suspect < do_not_read) )  
    printf("%c", suspect);  

另一个编辑,在阅读AndreyT的答案后,似乎是正确的.因此我会做这样的事情:

char letters[26];  
uintptr_t begin = letters;  
uintptr_t toofar = begin + sizeof(letters);  
char *suspect = somefunction_i_dont_control(letters,26);  
if( ((uintptr_t)suspect >= begin) && ((uintptr_t)suspect < toofar ) )
    printf("%c", suspect);  

感谢大家!

这个早期的问题询问this[0]C#中的含义.在C++中,this[0]意思是"指向的数组的第0个元素this".

是否保证不会在C++中导致未定义的行为以这种方式引用接收器对象？我并不主张使用这种语法,并且我很好奇这个规范是否能保证它始终有效.

谢谢!

我想知道是否存在以下区别:

1. 将基元变量转换为另一种基本类型
2. 将原始变量的地址的转换解除引用到另一个基本类型的指针

我还想知道是否有充分的理由使用(2)超过(1).我在遗留代码中看到过(2)这就是我想知道的原因.从上下文来看,我无法理解为什么(2)被优先于(1).从我写的下面的测试中,我得出的结论是,至少上传的行为在两种情况下都是相同的:

/* compile with gcc -lm */
#include <stdio.h>
#include <math.h>

int main(void)
{
    unsigned max_unsigned = pow(2, 8 * sizeof(unsigned)) - 1;

    printf("VALUES:\n");
    printf("%u\n", max_unsigned + 1);
    printf("%lu\n", (unsigned long)max_unsigned + 1);          /* case 1 */
    printf("%lu\n", *((unsigned long *)&max_unsigned) + 1);    /* case 2 */

    printf("SIZES:\n");
    printf("%d\n", sizeof(max_unsigned));
    printf("%d\n", sizeof((unsigned long)max_unsigned));       /* case 1 */
    printf("%d\n", sizeof(*((unsigned long *)&max_unsigned))); /* case 2 */

    return 0;
}

输出:

VALUES:
0
4294967296
4294967296
SIZES:
4
8
8 …

背景

今天刚和C人聊天,我们不同意以下几点:

int intgA[2] = { 1, 2 };
int intgB[2] = { 3, 5 };

int *intAPtr = intgA;
int *intBPtr = intgB;

所以当我们这样做时:

*intAPtr++ = *intBPtr++;

我的分析

第一:

intBPtr 增加1,现在指向地址5.然后,deference,保持值5;

intAPtr 也增加1,现在指向地址2.随后引用并且值为2;

最后:

2由5代替.

所以他们分别是:5和5.

他的分析

首先将值*intBPtr赋值为*intAPtrfirst.

因此,他们成为:3和3.

然后,两个*intAPtr和*intBPtr递增一.

所以,他们分别成为:4和4.

我的假设

我认为++运营商优先双双超过*和=,因此我断言.

例如,如果我们有:

*intAPtr++; 

结果应该是2,对吗？因为我们首先递增指针然后取消引用.

那么为什么在上述情况下,正如他所声称的那样,我们首先将值赋值给最后intBPtr的值intAPtr并增加值？

在完成了所有建议后,我在IDE中运行了代码,结果证实了@sujin:

虽然它确认我至少在优先权方面是正确的:

那: *intAPtr++ = *intBPtr++;

intAPtr++具有更高的优先级,这导致:将intAPtr其地址递增1.

现在指向:地址2.

同样地:

intBPtr++ 也增加1(地址). …

我的第一个问题是:有没有办法访问atomic<struct>对象中struct的成员？例如,我得到编译器错误:

struct std::atomic<node>’ has no member named ‘data’ a.data = 0; 

在这一部分

struct node{
  int data;
  node* next;
};

int main(){
  atomic<node> a;
  a.data = 0;
}

我可以通过创建一个像这样的临时节点来解决它:

  atomic<node> a;
  node temp;
  temp.data = 0;
  a.store(temp);

但这似乎并不优雅.

第二个问题是,如果我有一个指向原子对象的指针怎么办？反正有没有直接访问节点的成员？显然以下不编译,如何将其更改为在b的节点值中存储0？

atomic<node> b = new node;
b->data = 0;

这是我发现的一个解决方案,但同样,有更优雅的方式吗？

atomic<node> *b;
node temp;
temp.data = 0;
b->store(&temp);

最后,atomic<node*>和之间有什么区别atomic<node>*

我的代码如下:

main() {
    int array[5] = {3,6,9,-8,1};
    printf("the size of the array is %d\n", sizeof(array));
    printf("the address of array is %p\n", array);
    printf("the address of array is %p\n", &array);
    int * x = array;
    printf("the address of x is %p\n", x);
    printf("the size of x is %d\n", sizeof(x));
}

输出是

the size of the array is 20
the address of array is 0x7fff02309560
the address of array is 0x7fff02309560
the address of x is 0x7fff02309560
the size of x is …

我今天早些时候在programmers.stackexchange上发布了这个问题.我一直认为int (*)[]它不会衰减到int **函数参数中,但我得到了多个回答我的问题表明它确实存在.

我int (*)[]在我的函数参数中使用了很多,但现在我变得非常困惑.

当我使用编译此函数时 gcc -std=c99 -pedantic -Wall

void function(int (*a)[])
{
    sizeof(*a);
}

我收到此错误消息:

c99 -Wall -pedantic -c main.c -o main.o
main.c: In function ‘function’:
main.c:3:11: error: invalid application of ‘sizeof’ to incomplete type ‘int[]’ 
make: *** [main.o] Error 1

这表明*a有类型int []而不是int *.

有人可以解释一下,如果在函数参数中int (*)[]衰减int **,并给我一些参考(可能来自标准文档),这证明了为什么会这样.

我正在为一个数组分配内存,但我正在移动指针向前指向一点点.访问元素工作正常.它开始产生释放已分配内存的问题.Malloc抱怨从​​未分配被释放的指针.这个简化的代码可以重现这个问题:

int *pointer = malloc(sizeof(int)) + 1;
free(pointer - 1);

我开始尝试,发现代码的这种轻微变化可以工作.

int *pointer = malloc(sizeof(int));
pointer += 1;
free(pointer - 1);

什么是+ =做不同只是添加1指针malloc返回一行？

让我通过一个例子提出我的问题.

#include <memory>

std::unique_ptr<int> get_it() {
        auto p = new int;
        return p;
}

int main() {
        auto up ( get_it() );
        return 0;
}

无法编译时出现以下错误:

a.cpp:5:9: error: could not convert ‘p’ from ‘int*’ to ‘std::unique_ptr<int>’
  return p;
         ^

为什么没有从原始指针自动转换为唯一的指针？我应该做什么呢？

动机:我理解使用智能指针清除所有权应该是一种好习惯; 我从某个地方得到一个指针(我拥有),就像int*在这种情况下一样,我(想想我)想要它unique_ptr.

如果您正在考虑评论或添加您自己的答案,请在提案N4029中解决Herbert Sutter关于此问题的论点.