g(const char*, const char*, size_t);

К>void f(size_t n)
К>{
К>    if(n!=0)
К>    {
К>        std::vector<char> a(n), b(n);
К>        g(&a.front(), &b.front(), n);
К>    }
К>    else // если мы ничего не знаем про логику g(), попробуем максимально близко воспроизвести ситуацию
К>    {
К>        char a,b;
К>        g(&a,&b,0); // передаём два уникальных ненулевых адреса! ибо new char[0] != NULL
        
К>        // хотя, возможно, было бы достаточно
К>        g(NULL,NULL,0);
К>    }
К>    // или, в обобщённом виде
К>    std::vector<char> a(max(n,1)), b(max(n,1)); // гарантируем непустоту и уникальность
К>    g(&a.front(), &b.front(), n);
К>}
К>

A>Какие проблемы Вы видите в этих фрагментах кода и как предлагаете их решать?
A>1.
A>void g( char *, char *, size_t );
A>void f( size_t n )
A>{
A> char *a = new char[n];
A> char *b = new char[n];
A> g( a, b, n );
A> delete [] b;
A> delete [] a;
A>}
A>

void g( const char *, const char *, size_t );
void f( size_t n )
{
 сhar *a = NULL;
 char *b = NULL;
  
 if (n <= 0)
     return;
 try
 {
    a = new char[n];
    b = new char[n];
    g( a, b, n );
 }
 catch (...)
 {
    if (a) delete [] a;
    if (b) delete [] b;
 }
 if (a) delete [] a;
 if (b) delete [] b;
}

A>2.
A>int main(int argc, char* argv[])
A>{
A> if( argc > 1 )
A>  printf( argv[1] );
A> return 0;
A>}
A>

R>>void f( size_t n )
R>>{
R>> std::auto_ptr<char> a (new char[n]);
R>> std::auto_ptr<char> b (new char[n]);
R>> g( a.get(), b.get(), n );
R>>}

K> catch (...)
K> {
K>    if (a) delete [] a;
K>    if (b) delete [] b;
K> }
K> if (a) delete [] a;
K> if (b) delete [] b;

R>>>void f( size_t n )
R>>>{
R>>> std::auto_ptr<char> a (new char[n]);
R>>> std::auto_ptr<char> b (new char[n]);
R>>> g( a.get(), b.get(), n );
R>>>}
I>

1.
The delete-expression operator destroys a most derived object (1.8) or array created by a new-expression.

 delete-expression:
   ::opt delete cast-expression
   ::opt delete [ ] cast-expression

The first alternative is for non-array objects, and the second is for arrays. Whenever the delete keyword is immediately
followed by empty square brackets, it shall be interpreted as the second alternative.72) The operand shall have a pointer
type, or a class type having a single non-explicit conversion function (12.3.2) to a pointer type. The result has type void.
2.
If the operand has a class type, the operand is converted to a pointer type by calling the above-mentioned conversion
function, and the converted operand is used in place of the original operand for the remainder of this section. In either
alternative, the value of the operand of delete may be a null pointer value. If it is not a null pointer value, in the first
alternative (delete object), the value of the operand of delete shall be a pointer to a non-array object or a pointer to a
subobject (1.8) representing a base class of such an object (clause 10). If not, the behavior is undefined. In the second
alternative (delete array), the value of the operand of delete shall be the pointer value which resulted from a previous
array new-expression.73) If not, the behavior is undefined. [ Note: this means that the syntax of the delete-expression
must match the type of the object allocated by new, not the syntax of the new-expression. —end note ] [ Note: a pointer
to a const type can be the operand of a delete-expression; it is not necessary to cast away the constness (5.2.11) of the
pointer expression before it is used as the operand of the delete-expression. —end note ]
...

_>давно последний раз пробовали?

void f(const int* const a) {
    delete a;
}

int main() {
    f(new int);
}

const Obj* const ob = new Obj(10);
delete ob; // Error????