int sum=0;
    for_each(v.begin(), v.end(), 
        void(int i)
        {
            sum+=i;    
        }
    );

    int sum=0;
    for_each(v.begin(), v.end(), 
        void this(int i)
        {
            sum+=SomeMemberFunction(i);    
        }
    );

template<class T, class F>
F for_each(T& t, F f)
{
    return for_each(t.begin(), t.end(), f);
}

//Не могут быть определены конструкторы/деструктор
//но пустые protected виртуальный деструктор, конструктор по умолчанию, 
//копирующий конструктор, копирующие присваивание создюется автоматически
//
//Может быть наследован только от интерфейса(ов)
//
//Не может содержать данные
//
//По умолчанию pablic
interface ISome1
{
    virtual void Some1()=0;
    virtual void Some2()=0;
};
interface ISome2
    :ISome1
{
    virtual void Some3()=0;
    virtual void Some4()=0;
};
struct CSome1:ISome1
{
};
struct CSome2:ISome2
{
};
struct CSome:CSome1,CSome2
{
    virtual void Some1(){}
    virtual void Some2(){}
    virtual void Some3(){}
    virtual void Some4(){}
};
int main()
{
    ISome1* some=new CSome();//Ошибки не будет ибо будет выбран ЛЮБОЙ ISome1 тк они безразличны
}

#define BEG_END( arg ) arg.begin(), arg.end() 
исоответственно 
for_each( BEG_END( T ), f );

// file1.h
struct CMyStruct
{
  // ...
};

typedef std::vector<CMyStruct> CMyVector;


// file2.h
class CMyVector;  // или какое-то новое ключевое слово?


void SomeFunction(const CMyVector& vec);


// file2.cpp
#include "file2.h"
#include "file1.h"


void SomeFunction(const CMyVector& vec)
{
  // ...
}

   class PrintfParams
   {
   public:
     template <class T>
     PrintfParams & operator , (T val);
   };
   void printf(const char * format, [PrintfParams]);

   printf("%d, %s", 10, "Test");

   {
      PrintfParams tmpParams;
      tmpParams.operator , (10);
      tmpParams.operator , ("Test");
      printf("%d, %s", tmpParams);
   }

void TREGUnitData::Terminator(TREGBasePersonData* pEmployer)
{
 m_fkTerminator=m_TerminatorPtr=pEmployer;
}

• self_type& operator = (TREGBasePersonData* pEmployer);
  
• operator TREGBasePersonData* ()const;

• присвоить m_TerminatorPtr
  
• прочитать из m_TerminatorPtr
  
• присвоить m_fkTerminator

NW>Анонимные методы
NW>Я думаю не стоит этого делать, т.к. Функтор — это артефакт STL и воодить его в язык, как то странно.

W> template<class T, class F>
W> F for_each(T& t, F f)
W>

// [01]
template<class InputIterator1, class InputIterator2>
bool includes(InputIterator1, InputIterator1, InputIterator2, InputIterator2);

// [02]
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool includes(InputIterator1, InputIterator1, InputIterator2, InputIterator2, BinaryPredicate);

// сюда нужно добавить шесть перегруженных вариантов:

// [1]
template<class Container1, class InputIterator2>
bool includes(const Container1&, InputIterator2, InputIterator2);

// [2]
template<class InputIterator1, class Container2>
bool includes(InputIterator1, InputIterator1, const Container2&);

// [3]
template<class Container1, class Container2>
bool includes(const Container1&, const Container2&);

// [4]
template<class Container1, class InputIterator2, class BinaryPredicate>
bool includes(const Container1&, InputIterator2, InputIterator2, BinaryPredicate);

// [5]
template<class InputIterator1, class Container2>
bool includes(InputIterator1, InputIterator1, const Container2&, BinaryPredicate);

// [6]
template<class Container1, class Container2, class BinaryPredicate>
bool includes(const Container1&, const Container2&, BinaryPredicate);

W> //Не могут быть определены конструкторы/деструктор
W> //но пустые protected виртуальный деструктор, конструктор по умолчанию,
W> //копирующий конструктор, копирующие присваивание создюется автоматически
W> //Может быть наследован только от интерфейса(ов)
W> //Не может содержать данные
W>

void(*fnPtr)(int);
{
    int i=0;
    fnPtr=void(int x)//Создается не видимый, автоматический (не временный) обьект
        {
            i+=x;
        };
    //Тут валидно
    {
        //Тут валидно
    }
    //Тут валидно
}
//Тут невалидно
//И вобще он уже разрушился

Some& Fumc()
{
    Some some;
    return some;
}

for_each(mySuperPuperContainer.begin(), mySuperPuperContainer.end(), SomeFunctor);
//или
for_each(mySuperPuperContainer, SomeFunctor);

template<class T, class U>
void Test(T, T, U)
{
    std::cout<<"(T, T, U)"<<std::endl;
}
template<class T, class U>
void Test(T, U, U)
{
    std::cout<<"(T, U, U)"<<std::endl;
}
template<class T, class U, class D>
void Test(T, U, D)
{
    std::cout<<"(T, U, D)"<<std::endl;
}
template<class T, class U, class D>
void Test(T, U, U, D)
{
    std::cout<<"(T, U, U, D)"<<std::endl;
}
template<class T, class U, class D>
void Test(T, T, U, D)
{
    std::cout<<"(T, T, U, D)"<<std::endl;
}
template<class T, class U>
void Test(T, T, U, U)
{
    std::cout<<"(T, T, U, U)"<<std::endl;
}

int main()
{
    int i=0;
    float f=0;
    double d=0;
    Test(i, i, f);
    Test(i, f, f);
    Test(i, f, d);

    Test(i, i, f, f);
    Test(i, i, f, d);
    Test(i, f, f, d);
    return 0;
}

(T, T, U)
(T, U, U)
(T, U, D)
(T, T, U, U)
(T, T, U, D)
(T, U, U, D)

int sum=0;
for_each(vec, sum+=_1);
//Чем так
for_each(vec, void(int i)
            {
                sum+=i;
            }
        );

template<class T, class U>
void Test(T, T, const U&)
{
    std::cout<<"(T, T, U)"<<std::endl;
}
template<class T, class U>
void Test(const T&, U, U)
{
    std::cout<<"(T, U, U)"<<std::endl;
}
template<class T, class U, class D>
void Test(const T&, const U&, D)
{
    std::cout<<"(T, U, D)"<<std::endl;
}
template<class T, class U, class D>
void Test(const T&, U, U, D)
{
    std::cout<<"(T, U, U, D)"<<std::endl;
}
template<class T, class U, class D>
void Test(T, T, const U&, D)
{
    std::cout<<"(T, T, U, D)"<<std::endl;
}
template<class T, class U>
void Test(T, T, U, U)
{
    std::cout<<"(T, T, U, U)"<<std::endl;
}

int main()
{
    int i=0;
    float f=0;
    double d=0;
    Test(i, i, f);
    Test(i, f, f);
    Test(i, f, d);

    Test(i, i, f, f);
    Test(i, i, f, d);
    Test(i, f, f, d);
    return 0;
}

Comeau C/C++ 4.3.0.1 (Aug 21 2002 15:45:32) for MS_WINDOWS_x86
Copyright 1988-2002 Comeau Computing.  All rights reserved.
MODE:strict warnings C++

"test.cpp", line 39: error: more than one instance of overloaded function
          "Test" matches the argument list:
            function template "Test(T, T, const U &)"
            function template "Test(const T &, const U &, D)"
            argument types are: (int, int, float)
      Test(i, i, f);
      ^

"test.cpp", line 40: error: more than one instance of overloaded function
          "Test" matches the argument list:
            function template "Test(const T &, U, U)"
            function template "Test(const T &, const U &, D)"
            argument types are: (int, float, float)
      Test(i, f, f);
      ^

"test.cpp", line 43: error: more than one instance of overloaded function
          "Test" matches the argument list:
            function template "Test(T, T, const U &, D)"
            function template "Test(T, T, U, U)"
            argument types are: (int, int, float, float)
      Test(i, i, f, f);
      ^

3 errors detected in the compilation of "test.cpp".

void func(double *d)
{
 memset(d, 0, 3 * sizeof(double));
}

void func(double *d, int n)
{
 memset(d, 0, n * sizeof(double));
}