Confused About Pointer Question

I disagree with the answer to this quiz. A pointer is just a 32-bit variable. When you say Product *item = &tshirt, you are essentially creating a 32-bit variable named item and giving it the 32-bit memory address of tshirt. "Pointing to a memory address" just means that your pointer variable contains the memory address of the thing that you're pointing to.

In my opinion, the answer "Item contains the memory address of tshirt" is completely correct. In fact, if you run the program using a debugger or printing the address of your variables, you can see that that answer is correct.

The answer "Item points to the same memory address as tshirt and so contains the same value of tshirt" is partially correct. item does point to the same memory address as tshirt, since tshirt is essentially just the address of the first byte of the structure. However, item and tshirt do not contain the same value. If they did, you wouldn't need to use the dot operator to access tshirt.field1, but have to use the arrow operator to access item->field1. I agree that this is a poorly worded question, however Justin's answer is 100% correct.

EDIT: I'll clarify what I said above a little bit. When you declare a structure like tshirt, you get a block of memory that stores all of your structure's fields, one after another. So for example, suppose you declare a structure like this.

typedef struct Product
{
   int productId;   // this is 4 bytes
   char description[30];   // this is 30 bytes
   double price;   // this is 8 bytes
} Product;

The Product structure is 42 bytes. If you say Product tshirt = new Product();, then you get a 42-byte block of memory. The memory location of the variable tshirt is the first byte of those 42-bytes. Your compiler knows that if you say tshirt.productId then you want the first 4 bytes of your structure, starting at the first byte of tshirt. Similarly, if you say tshirt.price, then the compiler knows that you want 8 bytes, starting at the thirty-third byte of tshirt (since price is 33 bytes away from the start of the structure).

Now for the situation where you have the item pointer pointing to tshirt. You can't say item.productId because you don't want the first 4 bytes of item. You want the first four bytes of the thing that item points to. So first you go to the address that is stored in item and then you take the first 4 bytes of that. Contrast that with the above scenario where you just want the first 4 bytes of tshirt. This is a little more advanced than what's in that lesson, but that's what the different is between the dot operator and the arrow operator.

Here's some code from Wikipedia that further demonstrates that Justin's answer is correct.

struct point {
   int x;
   int y;
};
struct point my_point = { 3, 7 };
struct point *p = &my_point;  /* To declare and define p as a pointer of type struct point,
                                 and initialize it with the address of my_point. */

(*p).x = 8;                   /* To access the first member of the struct */
p->x = 8;                     /* Another way to access the first member of the struct */