Boost missing some data during serialization process

In my setup i have vector of OpacityChannel pointer as a member of Container class.

if i create a varible of OpacityChannel and write it to the archive than everything is written as expected.

when i write Container class object and write it to archive than it misses the data for KeyframeFloat class which is a member of OpacityChannel class.

This is my main file if i change the line from ar & cont; to ar & opacityChannel than it writes the data as required.

I am not able to understand why it is missing data when i write Container class.

#include "pch.h"
#include <iostream>
#include<fstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include "Container.h"
#include "KeyframeFloat.h"
#include <boost/serialization/export.hpp>


BOOST_CLASS_EXPORT_GUID(SumOpacity_Channel, "SumOpacity_Channel")
BOOST_CLASS_EXPORT_GUID(SumKeyframeFloat, "SumKeyframeFloat")

int main()
{
    const char* fileName = "saved.txt";
    std::vector<int> vec;
    Container cont;
    SumOpacity_Channel opacityChannel;
    SumKeyframeFloat key1, key2;
    opacityChannel.AddKeyframe(key1);
    opacityChannel.AddKeyframe(key2);
    cont.AddChannel(&opacityChannel);   
    SumKeyframeFloat key1_Restored, key2_Restored;

    {
        // Create an output archive
        std::ofstream ofs(fileName);        
        boost::archive::text_oarchive ar(ofs);  
        ar & cont; // KeyframeFloat data is not written.

        // if i do ar & opacityChannel; than keyframeFloat data is written in archive

    }

    Container c_Restored ;
    SumOpacity_Channel opacityChannel_Restored;

    //load data
    {
        //create an input stream
        std::ifstream ifs(fileName);        
        boost::archive::text_iarchive ar(ifs);
        ar & c_Restored ;
    }   

    do
    {
        std::cout << '\n' << "Press a key to continue...";
    } while (std::cin.get() != '\n');
} 

This is the container Class

#pragma once

#include <boost/serialization/base_object.hpp>
#include <boost/serialization/split_member.hpp>
#include "SumChannel.h"
#include "SumOpacityChannel.h"
#include <boost/serialization/vector.hpp>
#include <memory>
#include <boost/serialization/export.hpp>



class Container
{
private:
    std::vector< SumOpacity_Channel* > Channels;

public:

    Container() {} ;

    ~Container()
    {
        if(Channels.size() > 0 )
            for (int i = 0; i < Channels.size(); i++)
            {
                delete Channels[i];
            }
    }




    Container(const Container& c)
    {
        if (Channels.size() > 0)
            Channels.clear(); // clear any previous channels

        for (int i = 0; i < c.Channels.size(); i++)
        {
            Channels.push_back(c.Channels[i]->Clone());
        }

    }

    Container& operator=(const Container& c) 
    {
        if (Channels.size() > 0)
            Channels.clear(); // clear any previous channels

        for (int i = 0; i < c.Channels.size(); i++)
        {
            Channels.push_back(c.Channels[i]->Clone());
        }
        return *this;
    }


    void AddChannel(SumOpacity_Channel* channel)
    {
        Channels.push_back(channel->Clone());
    }


private:

    friend class boost::serialization::access;

    template <typename Archive>
    void save(Archive& ar, const unsigned version) const {
        ar  & Channels;
    }

    template <typename Archive>
    void load(Archive& ar, const unsigned version) {

        ar  & Channels;
    }

    BOOST_SERIALIZATION_SPLIT_MEMBER()

};

This is the keyframeFloat class.

#pragma once
#include "KeyframeBase.h"
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/serialization.hpp>

class SumKeyframeFloat
{
private:
    float x;

public:

    SumKeyframeFloat() { this->x = 0.0; };
    SumKeyframeFloat(float xvalue) : x(xvalue) { };
    SumKeyframeFloat(const SumKeyframeFloat& key) : x ( key.x) { };
    ~SumKeyframeFloat() = default;

private:

    friend class boost::serialization::access;

    template<typename Archive>
    void save(Archive& ar, const unsigned int version) const {
        std::cout << "writing float keyframe to Archive" << std::endl;

        ar & x;
    }

    template<typename Archive>
    void load(Archive& ar, const unsigned int version) {


        ar & x;
    }

    BOOST_SERIALIZATION_SPLIT_MEMBER()

};

This is sum Opacity class header and defination

#include <string>
#include "SumChannel.h"
#include <iostream>
#include <vector>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/vector.hpp>

class SumOpacity_Channel 
{
private:
    std::vector<SumKeyframeFloat>  keyframes;

public:
    SumOpacity_Channel();
    SumOpacity_Channel(const SumOpacity_Channel &opacityChannel);
    ~SumOpacity_Channel() = default;
    SumOpacity_Channel& operator=(const SumOpacity_Channel &posChannel);
    void AddKeyframe(SumKeyframeFloat key);
    void DeleteKeyframe(SumKeyframeFloat key, int number);
    SumOpacity_Channel* Clone() const;


public:
    friend class boost::serialization::access;

    template<typename Archive>
    void save(Archive& ar, const unsigned int version) const {  
        ar & keyframes;
    }

    template<typename Archive>
    void load(Archive& ar, const unsigned int version) {
        ar & keyframes;
    }


    BOOST_SERIALIZATION_SPLIT_MEMBER()

};

////////////////////////////////////////////////

#include "pch.h"
#include "SumOpacityChannel.h"


SumOpacity_Channel::SumOpacity_Channel() 
{

}
/////////////////////////////////////////////////////////////////////////////////////////////

    SumOpacity_Channel::SumOpacity_Channel(const SumOpacity_Channel &opacityChannel) 
    {
        this->keyframes.clear();
        for (auto KeyFrame : keyframes)
        {
            this->keyframes.push_back(KeyFrame);
        }
    }

    SumOpacity_Channel& SumOpacity_Channel::operator=(const SumOpacity_Channel &opacityChannel)
    {   
        for (auto KeyFrame : keyframes)
        {
            this->keyframes.push_back(KeyFrame);
        }
        return *this;
    }

    void SumOpacity_Channel::AddKeyframe(SumKeyframeFloat key)
    {
        keyframes.push_back(key);
    }

    void SumOpacity_Channel::DeleteKeyframe(SumKeyframeFloat key, int number)
    {
        keyframes.erase(keyframes.begin() + number);
    }

    SumOpacity_Channel* SumOpacity_Channel::Clone() const
    {
        return  new SumOpacity_Channel(*this);
    }