带指针和构造函数的typedef结构

Question

I am writing a struct _Point3d and typedefed it to Point3d and provided a pointer declaration PPoint3d next to Point3d (Please see code). There is a constructor which initializes members of the struct . I have twofold queries here.

typedef struct _Point3d
{
    float x;
    float y;
    float z;

    _Point3d(float _x, float _y, float _z) : x(_x), y(_y), z(_z)
    {

    }

}Point3d, *PPoint3d;

One: What does this convention of providing pointer after struct name (typedef) really means? provided we can create the pointer of Point3d like this

Point3d* _ppoint2 = new Point3d(1.0, 0.0, 0.0);

Two: Is there any difference in creating instances of Point3d in these two different ways.

PPoint3d _ppoint1 = new Point3d(0.0, 1.0, 0.0);
Point3d* _ppoint2 = new Point3d(1.0, 0.0, 0.0);

Answer 1

I am writing a struct _Point3d and typedefed it to Point3d and provided a pointer declaration *PPoint3d next to Point3d

Stop right there, Kiddo. This is 2016, not 1997. No need to follow arcane microsoft practice any more.

Do this instead:

struct Point3d
{
    float x;
    float y;
    float z;

    Point3d(float _x, float _y, float _z) : x(_x), y(_y), z(_z)
    {

    }
};

using PPoint3d = std::unique_ptr<Point3d>;
using SharedPoint3d = std::shared_ptr<Point3d>;

Raw pointers are to be used in low-level implementations. When used as part of an interface they make your code susceptible to being silently hijacked by your user's unintended and un-noticed mistakes.

For this reason they are evil when used as part of an interface. So evil that it is evil to even hint to users of your class that they should use them.

Answer 2

First, you are in C++, so you don't need to typedef your structs. You can write this.

struct Point3d {
//...
};

The typedef idiom is the norm in C, but not in C++ (and since you use new you clearly are in C++, not in C).

Secondly, there is no difference, as a typedef really is a type alias.

Answer 3

There are differences, but effectively the same thing is happening.

In

 Point3d* _ppoint2 = new Point3d(....);

You are taking the address of the new Point3d and storing it in the L-value (left hand side) called _ppoint2. You are doing the same with

 PPoint3d _ppoint1 = new Point3d(....);

The only difference is how you are writing the L-value.

_ppoint2 is a struct type, but you are annotating it with an asterisk to make it a pointer type. With _ppoint1 you have "baked in" the pointer to the struct.

Functionally they are identical except in type. This difference in type means that the manner in which you use them will differ, because that manner must be type-aware. For example, one does not need to include the asterisk to get the pointer value from _ppoint1.