Debug Assertion Failed Организация стека, string

#include <stdio.h>
#include <conio.h>
#include "mystack.h"
 
int main()
{
    int iRet = 0;
    fixedCapacityStackOfInt st;
    int N;
    char* item;
    bool bRun = true;
    char buf[32];
    char* cPtr = 0;
    cPtr = buf;
    printf("Enter stack capacity N =");
        scanf("%d",&N);
        stack_create(&st,N);
    while (bRun) 
    {
        printf("\nEnter data =");
        scanf("%s",&buf);
        switch (buf[0])
        { 
        case 'q':
            bRun = false;
            break;
        case '-':
            if (!stack_isEmpty(st))
            {
                item = stack_pop(&st);
                printf("%s ",item);
            }
            break;
        default:
            
            stack_push(&st, cPtr);
        }
    }
        printf("\nStack capacity N = %d size = %d\n\n",stack_size(st), stack_length(st));
        printf("\nStacks content:\n");
        while (!stack_isEmpty(st)) 
    {
        item = stack_pop(&st);
        printf("%s ",item);
    }
    stack_close(&st);
    cPtr = 0;
    _getch();
    return iRet;
}

#include "mystack.h"
#include <stdlib.h>
void stack_create(fixedCapacityStackOfInt* _stack, int cap)
{
    _stack->a = (char**)calloc(cap,sizeof(char*));
    _stack->N = 0;
    _stack->size = cap;
}
int stack_length(fixedCapacityStackOfInt _stack)
{
return _stack.size;
}
 
bool stack_isEmpty(fixedCapacityStackOfInt _stack)
{
    return _stack.N == 0;
}
 
void stack_resize(fixedCapacityStackOfInt *_stack, int newSize)
{
char **temp = (char**)calloc(newSize,sizeof(char*));
for (int i=0; i<_stack->N; i++)
{
    free(_stack->a[i]);
    _stack->a[i] = 0;
 
}
free(_stack->a);
_stack->a= temp;
temp = 0;
_stack->size = newSize;
}
 
int stack_size(fixedCapacityStackOfInt _stack)
{
    return _stack.N;
}
 
void stack_push(fixedCapacityStackOfInt* _stack, char* item)
{
    int i = _stack->N;
int st_max = _stack->size;
if (i == st_max)
stack_resize(_stack,2*st_max);
_stack->a[i] = item;
_stack->N = i+1;
}
 
char* stack_pop(fixedCapacityStackOfInt* _stack)
{
    char* item = 0;
    if (_stack)
    {
        int i = _stack->N;
        int st_max = _stack->size;
        item = _stack->a[i-1];
        _stack->N = --i;
        if ((i>0)&&(i <= st_max/4))
            stack_resize(_stack,st_max/2);
    }
    return item;
}
 
void stack_close(fixedCapacityStackOfInt* _stack)
{
 char* s=0;
for (int i=0; i<_stack->N; i++)
{
    s=_stack->a[i];
    delete [] s;
    _stack->a[i] = 0;
}
    
    free(_stack->a);
    _stack->a = 0;
}

struct fixedCapacityStackOfInt
{
    char **a;
    int N;
    int size;
};
    void stack_create(fixedCapacityStackOfInt *_stack, int cap);
    bool stack_isEmpty(fixedCapacityStackOfInt _stack);
    int stack_size(fixedCapacityStackOfInt _stack);
    int stack_length(fixedCapacityStackOfInt _stack);
    void stack_resize(fixedCapacityStackOfInt *_stack, int newSize);
    void stack_push(fixedCapacityStackOfInt *_stack, char* item);
    char* stack_pop(fixedCapacityStackOfInt *_stack);
    void stack_close(fixedCapacityStackOfInt *_stack);

  _stack->a = (char**)calloc(cap,sizeof(char*)); 
for(i=0;i<cap;i++)
   _stack->a[i]= (char*)calloc(100,sizeof(char));

for(i=0;i<cap;i++)
    free( _stack->a[i]); 
free( _stack->a);