Question

试着学习嵌套指针到结构的工作原理。如何在另一个指向结构的指针中访问结构指针内的元素？感谢。

#include <iostream>

typedef struct
{
  unsigned int            a;
  unsigned int            b;
  unsigned int            c;
} inner;

typedef struct
{
  unsigned int            d;
  unsigned int            e;
  inner * in;
} outer;

/* Function to use struct */
void test(outer * out)
{
  //Update the value of out->in->a.
  out->in->a = 5;
}

int main() {
  outer * out;
  test(out);

  std::cout << "My updated value: " << out->in->a << std::endl;
}

我得到了＃34;分段错误（核心转储）＆＃34;。

编辑：根据建议进行更改。

#include <iostream>

typedef struct
{
    unsigned int            a;
    unsigned int            b;
    unsigned int            c;
} inner;

typedef struct
{
    unsigned int            d;
    unsigned int            e;
    inner * in = new inner();
} outer;

/* Function to use struct */
void test(outer * out)
{
    //Update the value of out->d.
    out->d = 3; 
    //Update the value of out->in->a.
    out->in->a = 5;
}

int main() {

    outer out; 
    outer* p = &out; 

    test(p);

    std::cout << "My updated value for d: " << p->d << std::endl;
    std::cout << "My updated value for a: " << p->in->a << std::endl;
}

我现在更新了正确的值。但是我现在有一个警告

＆＃34;警告：非静态数据成员初始值设定项仅适用于-std = c ++ 11或-std = gnu ++ 11＆＃34;

inner * in = new inner();

如何修复此警告？

Answer 1

在test()功能中，out未指向任何有效内存位置。尝试取消引用该指针将调用undefined behavior。

因此，您需要将内存分配到out中的main()并将其传递给test()。

之后，out->in也是一个指针，你还需要为该指针分配内存，以便它指向一个有效的内存位置。确保所有指针指向有效的内存位置后，您可以继续取消引用它们。

Answer 2

好吧，对于初学者来说，你只有一个指向out的指针，它当前没有分配的内存：正如@IgorTandetnik所说，做到这一点：

outer out; outer* p = &out; test(p);你有一个未初始化的指针，指向任何有效的指针。

当测试使用out时，通过解除引用它，您基本上是未定义的行为，正如预期的那样，解除引用指向任何东西的指针。

接下来，in也遇到了同样的问题，它也没有分配内存。通过为in分配内存来解决这个问题，这个内存当前也会导致未定义的行为，就像之前一样。

此外，我很困惑为什么你有这些typedefs，但却标记了你的问题c++。如果您正在使用c编译器进行编译，那么它是有意义的，但是否则，您不需要在A c ++编译器中使用struct作为前缀，而c ++编译器已经为您完成了。

Answer 3

derefencing指针应该在某种形式的分配之后。

函数out->in->a = 5;内的
获取一个declared_but_not_initilized指针。你应该在out = new outer();之类的东西之前完成但是只有out指针可以被解除引用[实际上它可以在之前被解除引用但是会导致UB - 坏]，所以现在你shuold也分配给in指针out->in = new inner();就是这样的指针，就是这样：

/* Function to use struct */ void test(outer * out) { //Update the value of out->in->a. out->in = new inner(); // addition out->in->a = 5; } int main() { outer * out; out = new outer(); // addition test(out); std::cout << "My updated value: " << out->in->a << std::endl; }

注意：我使用了new，因为您使用#include <iostream>表示c ++。如果使用C，请使用malloc代替

Answer 4

首先，C和C ++是不同的语言。

在任何情况下，您必须在访问其元素之前分配结构抛出指针。否则使用未初始化的指针或指针，指向有效的结构＆＃39;对象导致程序的未定义行为。

这是一个演示C程序，演示如何使用指针

访问结构的元素

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

typedef struct
{
  unsigned int            a;
  unsigned int            b;
  unsigned int            c;
} inner;

typedef struct
{
  unsigned int            d;
  unsigned int            e;
  inner * in;
} outer;


int main( void ) 
{
    outer *out = malloc( sizeof( outer ) );

    if ( ( out != NULL ) && ( out->in = malloc( sizeof( inner ) ) ) )
    {
        out->in->a = 1;
        out->in->b = 2;
        out->in->c = 3;

        printf( "out->in = { a = %d, b = %d, c = %d }\n", out->in->a, out->in->b, out->in->c );

        free( out->in );
        free( out );
    }

    return 0;
}

它的输出是

out->in = { a = 1, b = 2, c = 3 }

在C ++中，程序看起来像

#include <iostream>

typedef struct
{
  unsigned int            a;
  unsigned int            b;
  unsigned int            c;
} inner;

typedef struct
{
  unsigned int            d;
  unsigned int            e;
  inner * in;
} outer;

int main() 
{
    outer *out = new outer;

    out->in = new inner;

    out->in->a = 1;
    out->in->b = 2;
    out->in->c = 3;

    std::cout << "out->in = { a = " << out->in->a
              << ", b = " << out->in->b
              << ", c = " << out->in->c
              << " }" << std::endl;

    delete out->in;
    delete out;

    return 0;
}

它的输出与上面显示的相同。

至于这个功能

void test(outer *out)
{
  //Update the value of out->in->a.
  out->in->a = 5;
}

然后指针out和in必须指向outer和inner类型的有效对象。

在另一个指向struct的指针内访问struct的指针内的元素

4 个答案: