C ++ struct和typdef

Question

I am not sure about the title because I don't know what it is really about.

I was trying to understand the code in the link below.

Color Based Particle Filter

I generally understand what the program does, but I couldn't figure out "state.h". What does this code do? Especially the "typedef", "State_" and "pp" parts look stranger to me.

I will put some of the code here for clarity reasons.

struct StateData;
struct State_;
typedef State_ (*State)(StateData&);
struct State_
{
    State_( State pp ) : p( pp ) { }
    operator State()
    {
        return p;
    }
    State p;
};

State_ state_start(StateData& d);
State_ state_selecting(StateData& d);
State_ state_initializing(StateData& d);
State_ state_tracking(StateData& d);

Any kind of help would be greatly appreciated.

Answer 1

Concisely: State is an alias for function pointer. State_ is a wrapper class that has a State member, and is implicitly convertible into that State .

The reason why State_ wrapper is needed, is because there is no way to express a function that returns a pointer to a function of the same type. The wrapper gets rid of the self-reference.

---

Line by line:

struct StateData;

A forward declaration of a class StateData .

struct State_;

A forward declaration of a class State_ .

typedef State_ (*State)(StateData&);

This one is a bit tricky. It defines State as a type alias for a function pointer that can point to a function that returns a State_ and takes a StateData& as an argument. The functions declared at the end of the snippet can be pointed by a function pointer of this type.

In my opinion, the chosen name is very confusing considering that there is already a State_ class. While I'm usually against hungarian notation, I would recommend to always apply a suffix or prefix to denote a function pointer, say state_fun or state_handler or state_callback ,

struct State_
{

This starts the definition of State_ calss.

    State_( State pp ) : p( pp ) { }

This defines a constructor for the class. The argument is of the function pointer type that was defined earlier. It initializes the member that will be declared shortly.

    operator State()
    {
        return p;
    }

A member function. More specifically, a user defined conversion into the function pointer type.

    State p;

Declares the member that was initialized in the constructor.

};

State_ state_start(StateData& d);
State_ state_selecting(StateData& d);
State_ state_initializing(StateData& d);
State_ state_tracking(StateData& d);

Free functions, that can be pointed by a State .

Answer 2

State_ is a structure type.

State is a pointer to function, accepting a parameter of type StateData& and returning State_ .

typedef ab; defines a type b which is exactly the same as a .

p is a field of class State_ , pp is a parameter of the constructor. p(pp) is a special syntax for constructor only, initializing p to the value of pp

Answer 3

This one declares a struct with name StateData

struct StateData;

The typedef keyword is use create a new alias for a type
Example:

typedef int mynumber; /// mynumber is an alias of type of int 
mynumber number = 3; /// so you can do this (number is a type of int just the int name is different)

one advantage of this is you can easily change the data type of the number variable specially if you have massive instances of mynumber:
Example:

typedef int mynumber;
mynumber number1 = 3;  
mynumber number2 = 4;
mynumber number3 = 5; 
// what if you want to make all this type of double? or a float? easy
// just change the int to a double or float like this
    typedef float mynumber;
    typedef double mynumber;

This one declares a struct with name State_

struct State_;

This one defines State_ that was declared above.

struct State_
{
    State_( State pp ) : p( pp ) { }
    operator State()
    {
        return p;
    }
    State p;
};

This one is list initializing the p . it initializes the p that was declared inside the struct (i,e. State p );

State_( State pp ) : p( pp )
{ 
}

These prototype functions returns State_ that accepts reference to StateData

State_ state_start(StateData& d);
State_ state_selecting(StateData& d);
State_ state_initializing(StateData& d);
State_ state_tracking(StateData& d);

Answer 4

typedef helps when defining pointer to function. You have a function with following header. State_ is the return type and the input is a reference to StateData.

State_ function (StateData&)

Then just add star (and parens to resolve precedence) to describe a pointer to this function.

State_ (*State) (StateData&)

Then put typedef in front of that to define it as a new type. Now you have a new type which can be used at other places. typedef is used to create type aliases which makes your code more readable.

typedef State_ (*State) (StateData&)

Now this type State can be used in another places. Declare a new variable p using this new type

State p

Use new State type as input to the constructor

State_(State pp)

Being able to specify pointer-to-function types using typedef make writing functions that take other functions as input much readable.