何时调用复制构造函数和析构函数，为什么调用

代码为:

#include <iostream>
class P_Node {
    friend class Picture;
protected:
    P_Node() : use(1) {}
    virtual ~P_Node() {}
private:
    int use;
};
class Picture {
    friend Picture frame(const Picture&);
public:
    Picture() : p(new P_Node) {
        std::cout << "Constructort" << "Picture::Picture()" << "tcalled" << std::endl;
        std::cout << "Picture p countt" << p->use << std::endl;
    }
    Picture(const Picture& orig) : p(orig.p) {
        std::cout << "Copy Constructort" << "Picture::Picture(const Picture&)" << "tcalled" << std::endl;
        std::cout << "Picture p countt" << p->use << std::endl;
        orig.p->use++;
    }
    ~Picture() {
        std::cout << "Destructort" << "Picture::~Picture()" << "tcalled" << std::endl;
        std::cout << "Picture p count before decreaset" << p->use << std::endl;
        if(--p->use == 0) {
            std::cout << "Picture p count after decreaset" << p->use << std::endl;
            std::cout << "Deleted" << std::endl;
            delete p;
        }
    }
    Picture& operator=(const Picture& orig) {
        std::cout << "operator=t" << "Picture& Picture::operator=(const Picture& orig)" << "tcalled" << std::endl;
        std::cout << "Picture p count before decreaset" << p->use << std::endl;
        orig.p->use++;
        if(--p->use == 0) {
            std::cout << "Picture p count after decreaset" << p->use << std::endl;
            std::cout << "Deleted" << std::endl;
            delete p;
        }
        p = orig.p;
        return *this;
    }
private:
    Picture(P_Node* p_node) : p(p_node) {
        std::cout << "Picture::Picture(P_Node* p_node)tcalled" << std::endl;
    }
    P_Node *p;
};
class Frame_Pic : public P_Node {
    friend Picture frame(const Picture&);
private:
    Frame_Pic(const Picture& pic) : p(pic) {
        std::cout << "Frame_Pic::Frame_Pic(const Picture& orig)" << "tcalled" << std::endl;
    }
    Picture p;
};
Picture frame(const Picture& pic) {
    return new Frame_Pic(pic);
}
int main() {
    Picture my_pic;
    Picture temp = frame(my_pic);
    return 0;
}

结果是:

<>之前构造函数Picture::Picture()被调用图片p计数1复制构造函数Picture::Picture(const Picture&)被调用图片p计数1Frame_Pic(const Picture& origin)被调用图片:图片(P_Node* P_Node)被调用析构函数Picture::~Picture()被调用图片计数前减少1图像p计数下降0后删除析构函数Picture::~Picture()被调用图片计数前减少2析构函数Picture::~Picture()被调用图片计数前减少1图像p计数下降0后删除

我之前问了一个关于这段代码的内存管理的问题，但是在理解了答案之后，我仍然对析构函数和复制构造函数有一个问题。在我的理解中，Picture temp = frame(my_pic)将调用复制构造函数。

1. 为什么不在Picture temp = frame(my_pic)
之后调用复制构造函数?
2. 为什么要调用析构函数?
3. 在Picture frame(const Picture& pic)中，如果函数被调用，复制构造函数会被调用吗?我相信是这样，因为它返回一个'图片'的值。
4. 如果我把Picture frame(const Picture& pic)改为Picture frame(Picture p)，当函数被调用时，复制构造函数会调用两次吗?
5. 何时调用复制构造函数?当类由函数按值返回时，会发生这种情况吗?当然后类传递给一个函数的值?
什么时候调用析构函数?是每次变量生命周期结束的时候吗?这是否意味着如果我通过值传递一个变量给一个函数，它的析构函数将在函数执行后被调用?

我现在搞混了复制构造函数和析构函数，特别是当我有一个带有返回值的函数，并且一些参数都是通过值传递的。

还有，谁能帮我在每一行的输出字符串上写一个注释?那太有帮助了。