strange error in c++ programing project

#include<limits.h>
#include<stdarg.h>
#include<math.h>
#include<string.h>
#include"bloom_filter.h"
#include"clru.h"
#include"uthash.h"
#include"stdafx.h"
#include"CDPSpace.h"
#include"Resource.h"
#include"sd.h"
#include"./lib/md5.h"
  CBloom_Filter::CBloom_Filter(){
BLOOM *bloom=CBloom_Filter::bloom_create((size_t)ceil(0.5*1*1.44), 1,MD5String);
  }
  CBloom_Filter::~CBloom_Filter(){


  }

 BLOOM *CBloom_Filter::bloom_create(size_t size, size_t nfuncs, ...)//bloom filter constructor.
{
    BLOOM *bloom;
    va_list l;//variable refer to the expected parameter (…)
    int n;

    if(!(bloom = (BLOOM *)malloc( sizeof(BLOOM)))) return NULL;//to allocate memory for bloom filter when is there is no bloom filter return null.
    if(!(bloom->a=(unsigned char *)calloc((size*COUNTER_BITS+CHAR_BIT-1)/(CHAR_BIT), sizeof(char)))) {
        free(bloom);
        return NULL;
    }//to allocate array of memory a(which represents pointer for key value) when it is fail just free the bloom filter and return null.

    if(!(bloom->funcs=(hashfunc_t*)malloc(nfuncs*sizeof(hashfunc_t)))) {
        free(bloom->a);
        free(bloom);
        return NULL;

}//to allocate memory for pointer to specific hash function when it fails it free memory reserved by a(pointer to key) and bloom filter and return null.


    va_start(l, nfuncs);//this macro we use it in order to  initializes (l) variable for subsequent use by va_arg and va_end, and must be called first.
//The parameter (nfuncs) is  the  name  of  the  last  parameter before  the variable argument list, i.e., the last parameter of which the calling function knows the type.
//Because the address of  this  parameter  is  used  in  the va_start  macro,  it  should not be declared as a register variable, or as a function or an array type. The va_start macro returns no value.


    for(n=0; n<nfuncs; ++n) {
        bloom->funcs[n]=va_arg(l, hashfunc_t);// The va_arg macro expands to an  expression  that  has  the type  and  value  of  the  next argument in the call.  The parameter(l)  is the va_list l  initialized  by  va_start.
//Each  call  to  va_arg  modifies (l) so that the next call returns the next argument.  The parameter type is  a  type
//name  specified so that the type of a pointer to an object that has the specified type  can  be  obtained  simply  by adding a * to type. If there is no next argument, or if type is not compatible with the type of the actual  next  argument  (as promoted
//according  to  the  default  argument  promotions), random errors will occur.
//The first use of  the  va_arg  macro  after  that  of  the va_start  macro  returns the argument after last.  Successive invocations return the values of the remaining arguments.

    }
    va_end(l);// The va_end macro handles a normal return from the function whose variable argument list was initialized by  va_start.

    if (!(bloom->PDATAINDEX[0]=(DATA_INDEX*)malloc((MAX_DATA_INDEX_NUM)*sizeof(DATA_INDEX)))){
        free(bloom->PDATAINDEX);
        free(bloom->a);
        free(bloom);
        return NULL ;
    }
    bloom->nfuncs=nfuncs;
    bloom->asize=size;
    const char *s=(const char*)bloom->a;


    memset(bloom->a,0,(size*COUNTER_BITS+CHAR_BIT-1)/(CHAR_BIT));


    return bloom;
}

int CBloom_Filter:: bloom_destroy(BLOOM *bloom)
{
    free((void*)bloom->asize);
    free(bloom->a);
    free(bloom->PDATAINDEX);
    free((void*)bloom->nfuncs);
    free(bloom->funcs);
    free(bloom);

    return 0;
}

int CBloom_Filter:: bloom_increament(BLOOM *bloom, const char *s)//where (s)is pointer for the key value
{
    size_t n;

    for(n=0; n<bloom->nfuncs; ++n) {

    if  (bloom->a[((*(bloom->funcs[n]))(s))%(bloom->asize)]<225)
        bloom->a[((*(bloom->funcs[n]))(s))%(bloom->asize)]++;

    }

    return 0;
}
int CBloom_Filter:: bloom_decrement(BLOOM *bloom,const char *s)
{
    size_t n;

    for(n=0;n<bloom->nfuncs;++n){
        if (bloom->a[((*(bloom->funcs[n]))(s))%(bloom->asize)]>0)
        bloom->a[((*(bloom->funcs[n]))(s))%(bloom->asize)]--;


    }
    return 0;
}
int CBloom_Filter::  bloom_check(BLOOM *bloom, const char *s)
{
    size_t n;

    for(n=0; n<bloom->nfuncs; ++n) {
        if(bloom->a[((*(bloom->funcs[n]))(s))%(bloom->asize)]>=1)

        return true;//here we substitute with key value in each hash function checking each corresponding counter which is equal to 1 or not
        else
        return false;
    }


}