1

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);
Improve this question
8
  • 1
    1) The typedefing of the pointer here is in my opinion the work of cranks that don't like the language syntax. 2) There is no difference. 3) Names in global namespace beginning with an underscore are reserved. Commented Mar 15, 2016 at 13:02
  • 5
    Why is this tagged C when you are using new? If this is just for C++ then the declaration does not follow the C++ convention for declaring and using classes. Commented Mar 15, 2016 at 13:03
  • 1
    actually I dont see the point of using a typedef here at all. imho it is much simpler and more clear to write struct Point3d { float x,y,z;} there is no need for a typedef Commented Mar 15, 2016 at 13:03
  • 1
    You write a lot of C code before, right ? So, forget everything and learn C++ like a new language Commented Mar 15, 2016 at 13:04
  • 1
    Related: Difference between 'struct' and 'typedef struct' in C++? Commented Mar 15, 2016 at 13:10

3 Answers 3

Reset to default
4

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

Can we get off the train of "raw pointers are so evil". There is nothing wrong with non-owning raw pointers.
@StoryTeller The reason for the existence of std::experimental:: observer_ptr is precisely because raw pointers are evil, especially when used as observers, simply because a user can hijack them by mistake.
@StoryTeller you're right. The language feature itself is necessary and 'not evil', but the use of it as part of an interface certainly is. I'll update the answer.
@A.B. I assume you mean when using the C features from the C++ programs? I would encourage you to wrap the C pointers in C++ smart pointers at the earliest opportunity. The custom deleter of the smart pointers makes this possible in every scenario.
@A.B. The win32 API was written in C a long time ago, and the MFC was written before people knew better (and indeed before c++ was mature). Microsoft's APIs are not a model of the future, more a warning about the past ;-)
|
3

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.

Improve this answer

Comments

1

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.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.