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>

                                    #include <vector>

void f( size_t n )
{
 сhar *a = NULL;                    std::vector<char> a(max(n,1));
 char *b = NULL;                    std::vector<char> b(max(n,1));
  
 if (n <= 0)                        //
     return;                        //
 try                                //
 {                                  //
    a = new char[n];                //
    b = new char[n];                //
    g( a, b, n );                   g(&a[0], &b[0], n);
 }                                  //
 catch (...)                        //
 {                                  //
    if (a) delete [] a;             //
    if (b) delete [] b;             //
 }                                  //
 if (a) delete [] a;                //
 if (b) delete [] b;                //
}

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

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

void g(std::vector<char>& a, std::vector<char>& b); // n не нужно, т.к. размеры переданы в составе объектов

// либо
void g(boost::shared_array<char> a, boost::shared_array<char> b, size_t n)

void f(size_t n)
{
  boost::shared_array<char> a(new char[n]), b(new char[n]);
  g(a,b,n); // g может передать права собственности куда-то на сторону
            // тогда по выходу из f() массивы останутся жить, как и задумано!
}

void GFuncCaller_NOSTL::clearBuff()
{
        if(!BufferA) delete[] BufferA;// Это не защита. Если BufferA==NULL, проблем с deleteA все равно нет
        BufferA = NULL;                // просто незачем вызывать delete

        if(!BufferB) delete[] BufferB;
        BufferB = NULL;
        
        gBufferSize = 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 );
}

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

const int valid_arguments_count = 1;

bool is_valid_arguments_count(int argc)
{
    return argc > valid_arguments_count;
}

int main(int argc, char* argv[])
{
    const int first_program_argument = 1;
    if( is_valid_arguments_count(argc) )
        std::cout << argv[first_program_argument] << std::endl;
    else
        std::cout << "Invalid arguments number. Valid: " << valid_arguments_count << std::endl;
    return 0;
}

void g(char* a, char* b, size_t n )
{
    // Функция на C.
    // Разместить что-нибудь в буферы для использования 
    // вызывающей функцией - традиционный способ 
    // Для контроля над правильностью размещения 
    // используется n. В данном случае - строка либо образается(но 0 не ставится),
    // либо дополняется нулями 
    if(!a || !b || !n)
        return; // на самом деле нормально написанная функция на C должна возвращать 
                // именованую константу, 
    
    strncpy(a, "one two three",n);
    a[n-1]='\0'; //
    
    strncpy(b, "three two one",n);
    b[n-1]='\0'; //
    
     // сделать что-нибудь еще
    printf("\n =====   func g said: Hello, I am C-styled legacy function . =============");
    printf("\n =====   func g said: Under my responsibility is not only placing something to buffers. =====");
    printf("\n ======  func g said: I am also says: 'Hello, word!' ==================="); 

    return;
};

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????

try
{
    pGFuncCaller = new GFuncCaller_STL(oSubSystem);
}
catch(exception &e)
{
    oSubSystem.log(e); 
        pGFuncCaller = NULL;
};
oSubSystem.execute(pGFuncCaller);

delete pGFuncCaller;
pGFuncCaller = NULL;

has no effect (5.3.5/2)

1. Какие проблемы Вы видите в этих фрагментах кода

2. Как предлагаете их решать?

Какие проблемы Вы видите в этих фрагментах кода и как предлагаете их решать?
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>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.

...

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;

void g( const char *, const char *, size_t );
void f( size_t n )
{
 сhar *a = malloc(n),
      *b = malloc(n);

 if (a && b) g( a, b, n );

 free(a);
 free(b);
}

void g(char* const a)
{
    char* aa = a;
    .......
    aa = bbbb;
    .......
}

7.17 Common definitions <stddef.h>

. . .


size_t

which is the unsigned integer type of the result of the sizeof operator

(ISO/IEC 9899:1999)