c++ - 访问指针指向的值

Question

编辑：这个问题应该被视为放弃。我已将此问题标记为删除，因为此时我什至不知道如何继续进行。我感谢你们所有人的意愿和抽出时间来帮助我。

我正在阅读并关注 cplusplus 关于数据结构的文档。我一直试图弄清楚为什么编译器不会接受“*pfruit.weight;”几个小时。可以肯定的是，我缺少一些简单的东西。

error C2228: left of '.weight' must have class/struct/union
1>          type is 'product *'
1>          did you intend to use '->' instead?

“句点 (.) 左侧的操作数不是类、结构或联合。”

那么我如何正确访问指针成员指向的值？（不访问引用）

#include <iostream>

using namespace std;

struct product
{
int weight;
float price;
} ;

int main ()
{
product afruit;
product * pfruit;
pfruit = &afruit;

pfruit->weight;
    //Access a member of an object to which we have a reference
//equivalent to: (*pfruit).weight

*pfruit.weight; //<------ I am so sorry, i meant This is the problem, i am using a reworded line of code from an example and it isn't compiling and returning the error.
    //Access the value pointed by a pointer member called weight;
//equivalent to: *(pfruit.weight)

system("pause");
return 0;
}

Answer 1

这段代码

struct product
{
int weight;
float price;
} ;

int main ()
{
    product * pfruit;

    *pfruit.weight;

是运算符优先级错误。C++ 的规则是.优先级高于*. *pfruit.weight如果pfruit是一个结构并且weight是一个指针，那将是正确的，但在你的代码中它是相反的，pfruit是指针并且weight只是一个 int。因此，您需要添加括号以正确地应用运算符

    (*pfruit).weight;

Answer 2

您可以使用以下语句：

(*pfruit).weight;

代替 ：

*pfruit.weight;

由于运算符优先级，它在编译时评估为以下内容：

*(pfruit.weight)

这是错误的，因为您正在取消引用非指针值并尝试使用.运算符而不是->.

编辑 ：

据我所知，这是关于指针和您的问题的一些回复和信息。

#include <iostream>

using namespace std;

struct product
{
  int   *weight;
  float price;
};

int             main()
{
  product       afruit;
  product       *pfruit;

  pfruit = &afruit;

  // Allocating 10 * sizeof(int) bytes of memory. ptr will now point to the first sizeof(int) bytes                                                                                                                                          
  // of the memory pointed by the weight pointer.                                                                                                                                                                                            
  pfruit->weight = new int[10];

  // The first sizeof(int) bytes of the memory pointed by ptr (equivalent to *ptr) equals now the value 4.                                                                                                                                   
  pfruit->weight[0] = 4;

  // The second sizeof(int) bytes of memory pointed by ptr (or (*ptr + 1)) equals now 42.                                                                                                                                                    
  pfruit->weight[1] = 42;

  // Dereferencing pfruit AND the pointer to the weight, thus returning the VALUE of the first sizeof(int) bytes of weight (4)                                                                                                               
  // instead of the value of the pointer to weight (0x8b4e008 for instance).                                                                                                                                                                
  int value = *(pfruit->weight);

  std::cout << "Value of pfruit->weight[0] = " << pfruit->weight[0] << std::endl
            << "Value of pfruit->weight[1] = " << pfruit->weight[1] << std::endl
            << "Value of *(pfruit->weight) = " << *(pfruit->weight) << std::endl
            << "Value of *(pfruit->weight + 1) = " << *(pfruit->weight + 1) << std::endl
            << "Value of ptr = " << std::hex << pfruit->weight << std::endl;

  // Prints :                                                                                                                                                                                                                                
  // Value of pfruit->weight[0] = 4                                                                                                                                                                                                          
  // Value of pfruit->weight[1] = 42                                                                                                                                                                                                         
  // Value of *(pfruit->weight) = 4                                                                                                                                                                                                          
  // Value of *(pfruit->weight + 1) = 42                                                                                                                                                                                                     
  // Value of ptr = 0x8b4e008                                                                                                                                                                                                                
  //                                                                                                                                                                                                                                         
  // Note that ptr[0] == *ptr and ptr[1] == (*ptr + 1)                                                                                                                                                                                       
  return (0);
}

Answer 3

派对迟到了，但试试这个：

听起来您希望像“int weight”这样的值以与通过 pfruit 引用产品相同的方式存储为指向其他地方的数据的指针。有些语言会这样做，但在 C++ 中，简单的数据成员（如您的体重和价格）将实际存储在产品数据结构中。因此，如果 afruit 恰好存在于内存中的地址 1000 处，则 pfruit 将具有值 1000：

... 1000  1001  1002  1003  ...
  --+-----+-----+-----+-----+--
    | afruit... |     |     |
  --+-----+-----+-----+-----+--
      ^
      |
      pfruit = 1000

这意味着您的重量 (int) 和价格 (float) 数据成员将一个接一个地存储在这里。（并且由于 int 和 float 的大小通常为 32 位，即 4 字节，因此内存如下所示：

... 1000  1001  1002  1003  1004  1005  1006  1007  ...
  --+-----+-----+-----+-----+-----+-----+-----+-----+--
    | afruit...                                     |
    | <------ weight -----> | <------ price ------> |
  --+-----+-----+-----+-----+-----+-----+-----+-----+--
      ^
      |
      pfruit = 1000

因此，pfruit 也恰好指向权重数据（因为它在结构中是第一个），但价格数据是 4 个字节。

因此，当您说要获取“按重量指向”的数据时，这是没有意义的，因为事实证明您不需要这样做，因为当您访问重量成员时，您已经在引用重量价值。它就在那里，在afruit占据的记忆中。

如果您尝试获取指向重量（或成本）数据本身的指针（而不是 afruit，或者实际上来自 pfruit），您可以执行以下操作：

int* pweight = &afruit.weight;  //from an actual product object
float* pcost = &pfruit->cost;   //via a pointer to a product object

现在有多种方法可以访问产品结构 afruit 的成员：

afruit.weight = 20;     //directly access the structure member
pfruit->weight = 10;    //follow the structure pointer
*pweight = 15;      //derefernce the int pointer

我希望这对某人有所帮助，至少有一点点。

山姆

Answer 4

一旦尝试这个你可能会得到它这可以写成 pfruit->weight 或 (*pfruit).weight

   (*pfruit).weight;

Answer 5

product afruit;
product * pfruit;
pfruit = &afruit;

pfruit->weight; 

pfruit是一个指针，具有 struct 的地址afruit。我们pfruit->weight在使用指针访问结构成员时使用。

当您使用结构名称时，您使用.运算符。现在，pfruit是指针。因此，结构本身是*pfruit

*pfruit.weight;

这被解释为*(pfruit.weight)，因为.具有比更高的优先级*。并且您不能.在 LHS 上使用带有指针的运算符

你必须清楚地表明你的意思(*pfruit).weight