Temporary object destruction

[Mortissus]

Hi

I was playing with the new operator overload that I have learned, the typecast operator. I made a little code that implements a specified behavior:

1) A manager is responsible for an object.
2) When needed, the manager assing a temporary employee to work on the object.
3) After the job is done, the employee is dismissed.
4) At the same time, the modified object is used for other activities

I noticed that, playing with the typecast operator I can return an operator from a function, so it will be destroyed automatically, and cast the operator to the object, so I can use it later. I know that this implementation is not good. I just want to know if this behavior is correct, if it is unsafe, compiler dependant, among others...

You can see the code here or by downloading the example.

Thanks for any help!

Edit: please, see program output to betetr understand what I mean

class Box {
public:
    Box () {
        thisId = ++id;
        cout << "Box " << thisId << " is now packed." << endl;
    }

    string getStatus () {
        char message[60];
        sprintf(message, "Box %d is now being assigned", thisId);
        return message;
    }

    ~Box () {
        cout << "Box " << thisId << " is now destroyed." << endl;
    }
private:
    static int id;
    int thisId;
};

int Box::id = 0;

template<class T>
class Operator {
public:
    Operator (T& obj)
    : object(obj) {
        object = obj;
        // do something to object
    }
    
    operator T* () {
        return &object;
    }
    
    ~Operator() {
        //write some log
        cout << "Operator dismissed." << endl;
    }
private:
    T& object;
};

template<class T>
class Manager {

public:
    Manager(T& obj)
    : object(obj) {
        object = obj;
        cout << "Manager is now leading." << endl;
    }
    
    T* getAnObject() {
        return (T*) Operator<T>(object);
    }
    

private:
    T& object;
};

int main() {
    Box box;
    Manager<Box> manager( box );

    string status = manager.getAnObject()->getStatus();
    
    cout << status << endl;
    
    // cin.get();
    
    return 0;
}

[CornedBee]

It's a misuse of the conversion operator overloading. You should only overload it if there's a meaningful equivalence between the two types in question. There is definitely no such thing in this case.

Also, the Operator ought to be destructed as getAnObject returns, which is probably too early.

[Mortissus]

It's a misuse of the conversion operator overloading. You should only overload it if there's a meaningful equivalence between the two types in question. There is definitely no such thing in this case.

I know, that's why I said that this solution is not good. It is just an example. I am more interested in the behavior.

I think that a better example would be a string being converted to an integer. Instead of overloading the = operator, the typecast could be used,... or not.

Also, the Operator ought to be destructed as getAnObject returns, which is probably too early.

Not in this case, it is my intention to destroy the operator exactly at that time, when he "delivers the box".

Edit: but, if the Operator is destroyed before the function returns, and not after, as would a normal temporary object, it isn't good.

I am interested in the reason why the operator is still correctly destroyed after I cast it to a pointer to another thing.