class TDBAddressConst
{
  const byte *buf_;
public:
  TDBAddressConst(const byte* buf);
  bool operator==(TDBAddressConst b) const;
  bool operator!=(TDBAddressConst b) const { return !(*this == b); }
  const byte* buf() const { return buf_; }  
  uint_fast8_t copyTo(void *trg) const;      
  // другие методы, не меняющие исходный объект
};

class TDBAddress : public TDBAddressConst
{
public:
  TDBAddress(byte* buf) : TDBAddressConst(buf) {}  
  byte* buf() const { return const_cast<byte*>(TDBAddressConst::buf()); }
  const TDBAddress& clear() const;  
  // другие методы, модифицирующие исходный объект
};

shared_ptr<Foo>       make_foo(byte*);
shared_ptr<const Foo> make_foo(const byte*);

template<bool const_> class TDBAddress;

template<typename internalData> 
class TDBAddressBase
{
protected:
   internalData* buf_;
public:
   // общие методы
};

template<> 
class TDBAddress<true> : public TDBAddressBase<const byte>
{
  // декларация константных методов. Возмождно их нет.
};

template<> 
class TDBAddress<false> : public TDBAddressBase<byte> 
               // можно : public TDBAddress<true>, но не желательно. Получим все недостатки твоей реализации.
{
  // декларация не константных методов.
};

// методы имеющие одинаковую реализацию, можно реализовать один раз
template<bool const_> 
TDBAddress<const_>::foo(...)
{ 
...
}

template<typename Stored>
class TDBAddress
{
   Stored* buf_;
   typedef TDBAddress<Stored> Self;
public:
   TDBAddress(Stored*buf) : buf_(buf) {}

   Stored buf() const { ... }
   
   typename boost::enable_if_c< ! boost::is_const<Stored>::value, const Self& >::type
   clear() const // только не-конст. версия
   {   
       // В принципе, можно и прямую ошибку компиляции вместо SFINAE
       // BOOST_STATIC_ASSERT( ! boost::is_const<Stored>::value );
       ...
   } 

   void foo() { ... }
};

template<typename Stored_>
void TDBAddress<const Stored_>::foo()
{
  /// если нужно специализировать реализацию отдельных методов ....
}

byte* buf() const { return const_cast<byte*>(TDBAddressConst::buf()); }

class TDBAddressConst
{
  /*const*/ byte *buf_;
public:
  TDBAddressConst(/*const*/ byte* buf);
  bool operator==(TDBAddressConst b) const;
  bool operator!=(TDBAddressConst b) const { return !(*this == b); }
  const byte* buf() const { return buf_; }  // Константный метод
  byte* buf() { return buf_; }              // Не константный метод
  const TDBAddress& clear() /* const */ ;   // Судя по названию, метод должен модифицировать объект,
                                            // поэтому он не может быть константным.

  uint_fast8_t copyTo(void *trg) const;      
};

A>class TDBAddressConst
A>{
A>  /*const*/ byte *buf_;
A>public:
A>  TDBAddressConst(/*const*/ byte* buf);
A>  bool operator==(TDBAddressConst b) const;
A>  bool operator!=(TDBAddressConst b) const { return !(*this == b); }
A>  const byte* buf() const { return buf_; }  // Константный метод
A>  byte* buf() { return buf_; }              // Не константный метод
A>  const TDBAddress& clear() /* const */ ;   // Судя по названию, метод должен модифицировать объект,
A>                                            // поэтому он не может быть константным.

A>  uint_fast8_t copyTo(void *trg) const;      
A>};
A>

// 1. const_cast переезжает в другие места и размножается:
const TDBAddress someMethod(const byte *buf) { return TDBAdress(const_cast<byte*>(buf); }

// 2. как запретить вызов неконстантных методов у объекта TDBAddress?
const byte *buf = ...;
TDBAddress  a = someMethod(buf); // присвоили константный объект неконстантному
a.clear(); // !!! ахтунг, модифицировали константный объект

.
— Доктор у меня тут вот хрустит, когда я вот так делаю.
— А зачем вы так делаете?

  const byte* buf() const { return buf_; }
  byte* buf() { return buf_; }

• если ваша сущность должна существовать быть поверх рид-онли сырого буфера, то запись туда должнабыть запрещена:
  1) либо вы не предоставляете неконстантных методов клиенту (то есть имеем две сущности: Const + NonConst)
  2) либо в рантайме рапортуете ошибку: то есть ваш get_buf, который возвращает неконстантный указатель, должен вернуть 0 (либо иным способом сообщить ошибку), этого можно добиться, сделать лишь один класс NonConst и создав дополнительную сущность Buffer, которая и будет в зависимости от константности char* возвращать данные или нули\ошибки)
  
• вы можете попробовать оторвать вашу сущность от сырого буфера и сделать ее мутабельной (внутри не-const мемберы)\немутабельной (внутри const, любая модификация выплевывает новый объект)
  при этом вам могут понадобиться методы сериализации\десериализации из сырого буфера (ведь он тут неслучайно, как я понимаю)
  
  

  const char* sourceBuffer = ...;
  NonConst object(sourceBuffer); //read content from sourceBuffer, but not store it inside
  object.Modify1();
  object.Modify2();
  char* destinationBuffer = ...;
  object.WriteTo(destinationBuffer);

1) OnNewMessage(const TDBAddress& newAddress);
2) OnNewMessage(const ConstTDBAddress& newAddress);

12.2/5 "Temporary objects":

The temporary to which the reference is bound or the temporary that is the complete object to a subobject of which the temporary is bound persists for the lifetime of the reference except as specified below. A temporary bound to a reference member in a constructor’s ctor-initializer (12.6.2) persists until the constructor exits. A temporary bound to a reference parameter in a function call (5.2.2) persists until the completion of the full expression containing the call.

запустить таки запустить

class TDBAddressConst
{
public:
  const byte* buf() const { return buf_; }

protected:
  byte *buf_;
};

class TDBAddress : public TDBAddressConst
{
public:
  byte* buf() const { return buf_; }
};

C>shared_ptr<Foo>       make_foo(byte*);
C>shared_ptr<const Foo> make_foo(const byte*);
C>

template<class T> class itself_ptr
{
  mutable T data_;
public:
  explicit itself_ptr(const T& src) : data_(src) {}

  T* operator->() const { return const_cast<T*>(&data_); }
  T& operator* () const { return const_cast<T&>( data_); }
};

template<class T> class itself_ptr
{
  mutable T data_;
public:
  explicit itself_ptr(const T& src) : data_(src) {}
 
  T* operator->() const { return &data_; }
  T& operator* () const { return data_; }
};

namespace detail {

struct TDBAddressImpl
{
  static int long_getter(const byte *buf);
  static void long_setter(byte *buf, double v);
};

}

template<class T>
class TDBAddress_
{
  T *buf_;
public:
  TDBAddress_(T *buf) : buf_(buf) {}
  
  byte getter() const { return buf_[105]; }
  void setter(byte v) { buf_[106] = v; }
  
  int long_getter() const { return detail::TDBAddressImpl::long_getter(buf_); }
};

typedef itself_ptr<TDBAddress_<byte> > TDBAddress;
typedef itself_ptr<TDBAddress_<const byte> > TDBAddressConst;

inline TDBAddress make_dbaddress(byte *buf) { return TDBAddress(TDBAddress_<byte>(buf)); }
inline TDBAddressConst make_dbaddress(const byte *buf) { return TDBAddressConst(TDBAddress_<const byte>(buf)); }