enum { __element_size = sizeof(_Ty) };

ME>class DataMapper : public Reference
ME>{
ME>public:
ME>    DataMapper();
ME>    ~DataMapper();
ME>    // ...
ME>private:
ME>    std::auto_ptr<struct DataMapperImpl> _pimpl; // непрозрачный указатель на реализацию
ME>};
ME>

17.4.3.6 Other functions
2 In particular, the effects are undefined in the following cases:
— if an incomplete type (3.9) is used as a template argument when instantiating a template component.

С>Sorry если вопрос глупый

///////////////////////////////////////////////////////////////////////////////
// DataMapper.h

#pragma once

#include "Reference.h"

class DataMapper : public Reference
{
public:
    DataMapper();
    ~DataMapper();
    // ...
private:
    std::auto_ptr<struct DataMapperImpl> _pimpl; // непрозрачный указатель на реализацию
};

///////////////////////////////////////////////////////////////////////////////
// DataMapper.cpp

#include "stdafx.h"
#include "DataMapper.h"

using namespace ADODB;
using namespace std;

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

struct DataMapperImpl
{
    DataMapperImpl() : _connection(__uuidof(Connection))
    {
        _connection->Open(sqlConnection, _bstr_t(), _bstr_t(), adConnectUnspecified);
    };

    _ConnectionPtr _connection;
};

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

DataMapper::DataMapper()
    :    _pimpl(new DataMapperImpl)
{
}

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

class SomeClass
{
public:
    SomeClass();
    virtual ~SomeClass();
    int DoSomething(int);
private:
    vector<int> m_V;
    map<int,int> m_M;
    // etc...
};

#include <vector>
#include <map>
#include <evrething> // :-)
#include "someclass.h"

#ifndef _VECTOR_
#error I need <vector> to be included in stdafx.h
#endif

ME>std::auto_ptr<struct DataMapperImpl> _pimpl; // непрозрачный указатель на реализацию

class DataMapper : public Reference
{
public:
    DataMapper();
    ~DataMapper();
private:
    //const std::auto_ptr<struct DataMapperImpl> _pimpl;
    struct DataMapperImpl* _pimpl;
};

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

struct DataMapperImpl
{
    DataMapperImpl() : _connection(__uuidof(Connection))
    {
        _connection->Open(sqlConnection, _bstr_t(), _bstr_t(), adConnectUnspecified);
    };

    _ConnectionPtr _connection;
};

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

DataMapper::DataMapper()
    :    _pimpl(new DataMapperImpl)
{
}

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

DataMapper::~DataMapper()
{
    delete _pimpl;
}

#ifndef RETAIL

#include "header1.h"
#include <header2.h>

struct MARC_RECORD
{
  int field1;
  char *field2;
};

#else

struct MARC_RECORD
{
  int unused;
}

#endif

typedef struct MARC_RECORD *HMARC;

int marc_get_field1 (HMARC mrc);

ifdef -DRETAIL ./marc.h -o ../retail/marc.h

class SomeClass
{
public:
    SomeClass();
    virtual ~SomeClass();
    int DoSomething(int);
#ifndef RETAIL
private:
    vector<int> m_V;
    map<int,int> m_M;
    // etc...
#endif
};

ssm>Ну тогда получаеться, что либо Герб незнает о таком пункте стандарта (что скорее всего врядли), либо знает и умышленно скрывает .

ssm>Ведь ясно в стандарте написано, что нельзя так делать. Как же быть

-if an incomplete type(3.9) is used as template argument when instanting a template component

#include "DataMapper.h"

int main(){

  DataMapper dm;  //я думаю что здесь, хочешь сказать, что в этой точке DataMapperImpl not incomplete type ?
...
}

ssm>#include "DataMapper.h"

ssm>int main(){

ssm>  DataMapper dm;  //я думаю что здесь, хочешь сказать, что в этой точке DataMapperImpl not incomplete type ?
ssm>...
ssm>}

DataMapper::DataMapper()
    :    _pimpl(new DataMapperImpl)
{
}

1.3.12 undefined behavior
behavior, such as might arise upon use of an erroneous program construct or erroneous data, for which this International Standard imposes no requirements. <...> [Note: permissible undefined behavior ranges from ignoring the situation completely with unpredictable results, to behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message).

//DataMapper.h
class DataMapper : public Reference{
...
  struct DataMapper * _pimpl;  
  f(){}
...
};

//DataMapper.cpp
DataMapper::DataMapper() : _pimpl(new DataMapperImpl()) {
  f();
}

DataMapper::~DataMapper() : _pimpl(new DataMapperImpl()) {
  delete _pimpl;
}

#include <iostream>

struct A{
  char dummy[1000];
  static int count;
  A(){ count ++;}
  ~A(){ count --;}
};

int A::count = 0;

class B{
public:
  B() : a(new A()){
     throw "!!!";
  }
  ~B() {delete a;}
private:
  A * a;
};


int main(){
  try{
    B b;  
  }
  catch(...)
  {
     std::cout << "Утечка памяти >= " << A::count * sizeof(A) << std::endl;
  }
}

ssm>int main(){
       return 0;  :))   
ssm>}

ssm>class B{
ssm>public:
ssm>  B() : a(new A()){
ssm>     throw "!!!";
ssm>  }
ssm>  ~B() {delete a;}
ssm>private:
ssm>  A * a;
ssm>};

#include <memory>

class B{
public:
  B() : a(new A()){
     throw "!!!";
  }
  ~B() {}
private:
    std::auto_ptr<A> a;
};

//user.h
template<class T>
class holder{
//something
private:
   std::auto_ptr<T>p_laja;
};

class Impl;
template<>
std::auto_ptr<Impl>::~auto_ptr();
//hidden.cpp
///definitions

ssm>#include <iostream>

ssm>struct A{
ssm>  char dummy[1000];
ssm>  static int count;
ssm>  A(){ count ++;}
ssm>  ~A(){ count --;}
ssm>};

ssm>int A::count = 0;

ssm>class B{
ssm>public:
ssm>  B() : a(new A()){
ssm>     throw "!!!";
ssm>  }
ssm>  ~B() {delete a;}
ssm>private:
ssm>  A * a;
ssm>};

ssm>
ssm>int main(){
ssm>  try{
ssm>    B b;  
ssm>  }
ssm>  catch(...)
ssm>  {
ssm>     std::cout << "Утечка памяти >= " << A::count * sizeof(A) << std::endl;
ssm>  }
ssm>}
ssm>

class B{
public:
    B()  { m_a = new A(); }
    ~B() { delete m_a; }
private:
    A * m_a;
};

but you couldn't write:

int illegal_function(my_class);

or:

my_class illegal_function();

struct illegal_class {
my_class f();
};

ssm>ну ты ведь 10 минут назад спрашивал зачем здесь auto_ptr<> твоя обертка — упрощенный до безобразия auto_ptr<>. вот ты сам и ответил на свой вопрос.

ssm> ну почему же только ресурсы? или генерить исключения умеет только operator new ?

ssm>ню-ню

ssm>    std::auto_ptr<ImplType> impl_;

ImplType* impl_;

#include <map>

struct C;

struct D
{
  std::map<int, C> m;

  D();
  D(const D&);
  ~D();
};