{
 public:
     Host( std::string address );
-    virtual ~Host();
+    ~Host();
 
     std::string get_address() const;
     void set_address( const std::string &address );
 
 {
 public:
     explicit DnsResolver( const std::string &dns_address );
-    virtual ~DnsResolver();
+    ~DnsResolver();
 
     bool resolve();
     int get_resolved_ip_count() const;
 
 public:
     HostAddress();
     HostAddress( std::string ip, int ttl );
-    virtual ~HostAddress();
+    ~HostAddress();
 
     std::string get_ip() const;
     void set_ip( std::string ip );
 
             const int ping_fail_percentage_limit,
             const boost::shared_ptr<LinkStatusAnalyzer> link_analyzer
     );
-    virtual ~HostStatusAnalyzer();
+    ~HostStatusAnalyzer();
 
     void set_resolved_ip_count( const int resolved_ip_count );
     bool exceeded_ping_failed_limit() const;
 
 {
 public:
     PingInterval( T interval );
+    ~PingInterval();
 
     operator T();
 
     }
 
 template<typename T>
+    PingInterval<T>::~PingInterval()
+    {
+    }
+
+template<typename T>
     PingInterval<T>::operator T()
     {
         return Interval;
 
             const int ping_fail_percentage_limit,
             boost::shared_ptr<LinkStatusAnalyzer> link_analyzer
     );
-    virtual ~PingScheduler();
+    ~PingScheduler();
 
     bool start_pinging();
 
 
             const int link_up_interval_in_min,
             const std::string &status_notifier_cmd
     );
-    virtual ~LinkStatusAnalyzer();
+    ~LinkStatusAnalyzer();
 
     void notify_host_up( const std::string &host_address );
     void notify_host_down( const std::string &host_address );