typedef size_t TypedCounterType;
typedef TypedCounterType CountType;
typedef TypedCounterType IndexType;

typedef size_t UntypedCounterType;
typedef UntypedCounterType SizeType;
typedef UntypedCounterType OffsetType;

void foo()
{
    IndexType idx = 10;
    OffsetType offs;

    offs = idx; // Как сделать, чтобы это было невозможно (носвместимость типов)
                    // или хотя-бы Warning ?
}

class TypedCounterType<size_t id>
{
public:
    operator int() { ... };
    ...
};
// то
typedef TypedCounterType<0> type1;
typedef TypedCounterType<1> type2;

type1 a;
type2 b;

a = b; // Увы, работает  :(

template<class Type, int id>
class TypedCounterType
{
public:
    operator Type&() { return n; };
    Type n;
};
// то
typedef TypedCounterType<double, 1> type1;
typedef TypedCounterType<double, 2> type2;

type1 a;
type2 b;

a = b; // Увы, работает  :(

C>typedef size_t TypedCounterType;
C>typedef TypedCounterType CountType;
C>typedef TypedCounterType IndexType;

C>typedef size_t UntypedCounterType;
C>typedef UntypedCounterType SizeType;
C>typedef UntypedCounterType OffsetType;
C>

C>void foo()
C>{
C>    IndexType idx = 10;
C>    OffsetType offs;

C>    offs = idx; // Как сделать, чтобы это было невозможно (носвместимость типов)
C>                    // или хотя-бы Warning ?
C>}
C>

#include <iostream>

template <class T, class ID> 
class wrap {
    typename T data_;
public:
    wrap() {}
  wrap(const T& init): data_(init) {}

    operator typename T() {
        return data_;
    }
};

typedef wrap<int, class id1> type1;
typedef wrap<int, class id2> type2;

int main() {
    type1 a1, b1=5;
    type2 a2=1;

    a1=b1;  // ok
    a1=4;   // ok
    a1=a2;  // не компилится

    std::cout<<a1<<std::endl;
}

Y>#include <iostream>

Y>template <class T, class ID> 
Y>class wrap {
Y>    typename T data_;
Y>public:
Y>    wrap() {}
Y>  wrap(const T& init): data_(init) {}

Y>    operator typename T() {
Y>        return data_;
Y>    }
Y>};

Y>typedef wrap<int, class id1> type1;
Y>typedef wrap<int, class id2> type2;

Y>int main() {
Y>    type1 a1, b1=5;
Y>    type2 a2=1;

Y>    a1=b1;  // ok
Y>    a1=4;   // ok
Y>    a1=a2;  // не компилится

Y>    std::cout<<a1<<std::endl;
Y>}
Y>

    a1 += 10;
    ++a1;

introduce_type int my_integral;

introduce_template std::vector<class T, my_allocator> vector_with_my_allocator<class T>;

C>typedef size_t TypedCounterType;
C>typedef TypedCounterType CountType;
C>typedef TypedCounterType IndexType;

C>typedef size_t UntypedCounterType;
C>typedef UntypedCounterType SizeType;
C>typedef UntypedCounterType OffsetType;
C>

C>void foo()
C>{
C>    IndexType idx = 10;
C>    OffsetType offs;

C>    offs = idx; // Как сделать, чтобы это было невозможно (носвместимость типов)
C>                    // или хотя-бы Warning ?
C>}
C>

enum IndexType { IndexTypeMin = 0, IndexTypeMax = UINT_MAX };
enum OffsetType { OffsetTypeMin = 0, OffsetTypeMax = UINT_MAX };

void foo()
{
    IndexType idx = (IndexType)10;
    OffsetType offs;

    offs = idx; // error
}

C>typedef size_t TypedCounterType;
C>typedef TypedCounterType CountType;
C>typedef TypedCounterType IndexType;

C>typedef size_t UntypedCounterType;
C>typedef UntypedCounterType SizeType;
C>typedef UntypedCounterType OffsetType;
C>

C>void foo()
C>{
C>    IndexType idx = 10;
C>    OffsetType offs;

C>    offs = idx; // Как сделать, чтобы это было невозможно (носвместимость типов)
C>                    // или хотя-бы Warning ?
C>}
C>

enum TypeCounterType {};

inline TypeCounterType toTypeCounterType(int i) { return static_cast<TypeCounterType>(i); }

// определим нужные нам операторы (их оказывается, как правило, немного)
inline TypeCounterType & operator ++ (TypeCounterType & t)
{
    return t = toTypeCounterType(t + 1);
}

enum UntypedCounterType {};

#include <iostream>

template <class T, class ID> 
class wrap {
    typename T data_;
public:
    wrap() {}
  wrap(const T& init): data_(init) {}

    operator typename T() {
        return data_;
    }
};

typedef wrap<int, class id1> type1;
typedef wrap<int, class id2> type2;

int main() {
    type1 a1, b1=5;
    type2 a2=1;

    a1=b1;  // ok
    a1=4;   // ok
    a1=a2;  // не компилится
    int r = a1 + a2; // компилится

    std::cout<<a1<<std::endl;
}

V>иногда нада.

//  Copyright 1997-2003 Adobe Systems Incorporated. All rights reserved.
//  
//  NOTICE:  Adobe permits you to use, modify, and distribute this file in accordance 
//  with the terms of the Adobe license agreement accompanying it.  If you have received
//  this file from a source other than Adobe, then your use, modification, or 
//  distribution of it requires the prior written permission of Adobe.


// ===================================================================================
//    PODTraits
//         POD stands for Plain Old Data
// ===================================================================================

struct base_type  { typedef  base_type   data_type;};
struct object_type{ typedef  object_type data_type;};


/** 32 bit signed integer */
typedef long int32;

/** 32 bit unsigned integer */
typedef unsigned long uint32;


/** IDType is the underlying base type used for representing any type that is an 
    InDesign ID-space. An ID-space is an integer composed of a plug-in prefix, 
    plus a one-byte offset. Each identifier within the id-space is unique. We
    use IDType as a base class in order to detect mismatches between them at 
    runtime. For instance, if you pass a ClassID to something that expects an
    IID, that will cause a compile time error instead of a (relatively more costly
    to fix) runtime error.
    
    IDTypes can be used pretty much interchangeably as if they were integers. The
    exceptions to this rule are if they are being used in a switch statement, and
    when you are reading them in or out of resources. For cases where you simply 
    must have an integer, we supply the Get() function.
*/
template<class T>
class IDType
{
    public:
        typedef base_type data_type;
        typedef int32 difference_type;
        typedef uint32 value_type;

        IDType() : fIDInt(0) {}
        //~IDType() {}
        IDType(value_type sourceInt) : fIDInt(sourceInt) {}
        IDType(const IDType& sourceIDClass) : fIDInt(sourceIDClass.fIDInt) {}
        IDType& operator=(const value_type& sourceInt) {fIDInt = sourceInt; return *this;}
        IDType& operator=(const IDType& sourceIDClass) {fIDInt = sourceIDClass.fIDInt; return *this;}

        bool operator>(const IDType& rhs) const { return fIDInt > rhs.fIDInt; }
        bool operator>(const value_type& rhs) const { return fIDInt > rhs; }
        friend bool operator>(const value_type& lhs, const IDType<T>& rhs) { return lhs > rhs.fIDInt; }

        bool operator<(const IDType& rhs) const { return fIDInt < rhs.fIDInt; }
        bool operator<(const value_type& rhs) const { return fIDInt < rhs; }
        friend bool operator<(const value_type& lhs, const IDType<T>& rhs) { return lhs < rhs.fIDInt; }

        bool operator<=(const IDType& rhs) const { return !(fIDInt > rhs.fIDInt); }
        bool operator<=(const value_type& rhs) const { return !(fIDInt > rhs); }
        friend bool operator<=(const value_type& lhs, const IDType<T>& rhs) { return !(lhs > rhs.fIDInt); }

        bool operator>=(const IDType& rhs) const { return !(fIDInt < rhs.fIDInt); }
        bool operator>=(const value_type& rhs) const { return !(fIDInt < rhs); }
        friend bool operator>=(const value_type& lhs, const IDType<T>& rhs) { return !(lhs < rhs.fIDInt); }

        bool operator==(const IDType& rhs) const { return fIDInt == rhs.fIDInt; }
        friend bool operator==(const value_type& lhs, const IDType<T>& rhs) { return lhs == rhs.fIDInt; }

        bool operator!=(const IDType& rhs) const { return !(fIDInt == rhs.fIDInt); }
        bool operator!=(const value_type& rhs) const { return !(fIDInt == rhs); }
        friend bool operator!=(const value_type& lhs, const IDType<T>& rhs) { return !(lhs == rhs.fIDInt); }

        IDType& operator+=(const difference_type& rhs) { fIDInt += rhs; return *this; }
        friend IDType<T> operator+(const IDType<T>& lhs, const difference_type& rhs) { return IDType<T>(lhs) += rhs; }
        friend IDType<T> operator+(const IDType<T>& lhs, const IDType<T>& rhs) { return IDType<T>(lhs) += rhs.fIDInt; }
        friend IDType<T> operator+(const difference_type& lhs, const IDType<T> rhs) { return IDType<T>(rhs) += lhs; }

        // prefix
        IDType& operator++() { *this += 1; return *this; }
        // postfix
        const IDType operator++(int) { IDType oldValue = *this; ++(*this); return oldValue; }

        IDType& operator-=(const IDType& rhs) { fIDInt - rhs.fIDInt; return *this; }
        IDType& operator-=(const difference_type& rhs) { fIDInt - rhs; return *this; }
        friend IDType<T> operator-(const difference_type& lhs, IDType<T> rhs) { return IDType<T>(rhs) -= lhs; }
        friend difference_type operator-(const IDType<T>& lhs, const difference_type& rhs) { return lhs.fIDInt - rhs; }
        friend difference_type operator-(const IDType<T>& lhs, const IDType<T>& rhs) { return lhs.fIDInt - rhs.fIDInt; }

        // prefix
        IDType& operator--() { *this -= 1; return *this; }
        // postfix
        const IDType operator--(int) { IDType oldValue = *this; --(*this); return oldValue; }

        value_type operator>>(const int& rhs) const { return fIDInt >> rhs; }
        value_type operator<<(const int& rhs) const { return fIDInt << rhs; }

        value_type operator&(const value_type& rhs) const { return fIDInt & rhs; }
        friend value_type operator&(const value_type& lhs, const IDType<T>& rhs) { return IDType<T>(rhs) & lhs; }

        value_type operator|(const value_type& rhs) { return fIDInt | rhs; }
        friend value_type operator|(const value_type& lhs, const IDType<T>& rhs) { return IDType<T>(rhs) | lhs; }

        IDType& operator|=(const value_type& rhs) { fIDInt |= rhs; return *this; }
//        friend value_type operator|=(const value_type& lhs, const IDType<T>& rhs) { lhs |= rhs.fIDInt; return lhs; }

        value_type& Get() { return fIDInt; }
        inline const value_type& Get() const { return fIDInt; }

        bool IsValid() const { return (fIDInt != 0); }

//        operator uint32&() { return fIDInt; }
//        operator uint32() { return fIDInt; }

    private:
        value_type fIDInt;
};

...
ssm>

struct TypedCounterTypeTag{};
typedef IDType<TypedCounterTypeTag> CountType;
typedef IDType<TypedCounterTypeTag> IndexType;

struct UntypedCounterTypeTag{};
typedef IDType<UntypedCounterTypeTag> SizeType;
typedef IDType<UntypedCounterTypeTag> OffsetType;

        IDType(value_type sourceInt)

IndexType inline operator + (IndexType i1, IndexType i2)
{ return IndexType((int)i1 + (int)i2); }

// прячем операторы в namespace, дабы избежать конфликтов
namespace Typed {

    template<typename T>
    struct type_trait {
        typedef int base_type;
    };

    // маленький трюк, частично защитимся от встроенного преобразования enum --> int
    template<typename T>
    struct type_holder {
        T value;
        type_holder(const T& value_) : value(value_) {}
        operator T() { return value; }

    private:
        operator int();
    };

    // тут все операторы:

    template <typename T> type_holder<T> operator + (T i1, T i2) { 
        typedef typename type_trait<T>::base_type base_type;
        return T(base_type(i1) + base_type(i2)); 
    }

    template <typename T> type_holder<T> operator - (T i1, T i2) { 
        typedef typename type_trait<T>::base_type base_type;
        return T(base_type(i1) - base_type(i2)); 
    }

    template <typename T> T& operator += (T& i1, T i2) { 
        typedef typename type_trait<T>::base_type base_type;
        return (T&)((base_type&)(i1) += base_type(i2)); 
    }

    // аналогично для тонны других операторов...

}

namespace Typed {  
    enum IndexType {};
}

int main(int argc, _TCHAR* argv[]) {
    using namespace Typed;

    IndexType it1 = IndexType(1), it2=IndexType(2);
    int i1 = 1, i2 =2;

    IndexType it3 = it1 + it2;
    it3 += it1;

    // fail
    int i4 = it1 + it2;

    // fail
    unsigned u1 = it1 + it2;
    
    // fail, пусть все методы и ф-ии возвращают type_holder<T>
    // в этом случае мы сможем присвоить результат T но не int
    int i5 = type_holder<IndexType>(it1);

    return 0;
}

friend bool operator<=(const value_type& lhs, const IDType<T>& rhs) { return !(lhs > rhs.fIDInt); }