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

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

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 f( size_t n )
{
 std::auto_ptr<char> a (new char[n]);
 std::auto_ptr<char> b (new char[n]);
 g( a.get(), b.get(), 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>>

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>}
R>

void f( size_t n )
{
 std::vector<char> a (n);
 std::vector<char> b (n);
 g( &a[0], &b[0], n );
}

void f( size_t n )
{
 boost::scoped_array<char> a (new char[n]);
 boost::scoped_array<char> b (new char[n]);
 g( a.get(), b.get(), 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>2.
A>int main(int argc, char* argv[])
A>{
A> if( argc > 1 )
A>  printf( argv[1] );
A> return 0;
A>}

A>

g может "испортить" указатели

g(char*a , char* b, size_t)
{
    delete a;
    delete[] b;
}

S>>void f( size_t n )
S>>{
S>> std::vector<char> a (n);
S>> std::vector<char> b (n);
S>> g( &a[0], &b[0], n );
S>>}
S>>

Item 16. Know how to pass vector and string data to legacy APIs.

Since C++ was standardized in 1998, the C++ elite haven't been terribly subtle in their attempt to nudge programmers away from arrays and towards vectors. They've been similarly overt in trying to get developers to shift from char* pointers to string objects. There are good reasons for making these changes, including the elimination of common programming errors (see Item 13) and the ability to take full advantage of the power of the STL algorithms (see. e.g., Item 31).
Still, obstacles remain, and one of the most common is the existence of legacy C APIs that traffic in arrays and char* pointers instead of vector and string objects. Such APIs will exist for a long time, so we must make peace with them if we are to use the STL effectively.
Fortunately, it's easy. If you have a vector v and you need to get a pointer to the data in v that can be viewed as an array, just use &v[0]. For a string s, the corresponding incantation is simply s.c_str(). But read on. As the fine print in advertising often points out, certain restrictions apply.
Given

vector<int> v;

the expression v[0] yields a reference to the first element in the vector, so &v[0] is a pointer to that first element. The elements in a vector are constrained by the C++ Standard to be stored in contiguous memory, just like an array, so if we wish to pass v to a C API that looks something like this.
void doSomething(const int* pInts, size_t numlnts);
we can do it like this:

doSomething(&v[0], v.size());

Maybe. Probably. The only sticking point is if v is empty. If it is, v.size() is zero, and &v[0] attempts to produce a pointer to something that does not exist. Not good. Undefined results. A safer way to code the call is this:

if (!v.empty()) {
doSomething(&v[0], v.size());
}

If you travel in the wrong circles, you may run across shady characters who will tell you that you can use v.begin() in place of &v[0], because (these loathsome creatures will tell you) begin returns an iterator into the vector, and for vectors, iterators are really pointers. That's often true, but as Item 50 reveals, it's not always true, and you should never rely on it. The return type of begin is an iterator, not a pointer, and you should never use begin when you need to get a pointer to the data in a vector. If you're determined to type v.begin() for some reason, type &*v.begin(), because that will yield the same pointer as &v[0], though it's more work for you as a typist and more obscure for people trying to make sense of your code. Frankly, if you're hanging out with people who tell you to use v.begin() instead of &v[0], you need to rethink your social circle.

...

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);
}