C++ std::free方法代码示例

/**
  <summary>
  Releases a valid red black tree
  <summary>
  <param name="tree">The tree to release</param>
  <remarks>
  The tree must have been created using jsw_rbnew
  </remarks>
*/
void jsw_rbdelete ( jsw_rbtree_t *tree )
{
  jsw_rbnode_t *it = tree->root;
  jsw_rbnode_t *save;

  /*
    Rotate away the left links so that
    we can treat this like the destruction
    of a linked list
  */
  while ( it != NULL ) {
    if ( it->link[0] == NULL ) {
      /* No left links, just kill the node and move on */
      save = it->link[1];
      jsw_keyFree( tree, it->key );
      free ( it );
    }
    else {
      /* Rotate away the left link and check again */
      save = it->link[0];
      it->link[0] = save->link[1];
      save->link[1] = it;
    }

    it = save;
  }

  free ( tree );
}

//------------------------------------------------------------------------------
AMemory::~AMemory()
{
	if(mHeap)
	{
		free(mHeap);
		mHeap = 0x0;
	}
}

void jsw_keyFree( jsw_rbtree_t *tree, void *key )
{
    if (tree->type) {
        cx_type keyType = cx_map(tree->type)->keyType;

        if (keyType->reference) {
            cx_free(*(cx_object*)key);
        } else {
            if (keyType->kind == CX_PRIMITIVE) {
                if (cx_primitive(keyType)->kind == CX_TEXT) {
                    free(*(cx_string*)key);
                }
            }
        }
        free(key);
    }
}

// Releases Data for linked objects
void EERIE_LINKEDOBJ_ReleaseData(EERIE_3DOBJ * obj)
{
	if (obj == NULL) return;

	if (obj->linked) free(obj->linked);

	obj->linked = NULL;
	obj->nblinked = 0;
}

//------------------------------------------------------------------------------
void AMemory::Deallocate(void)
{
	if(mHeap)
	{
		free(mHeap);
		mHeap = 0x0;
		mSize = 0;
	}
}

MblMwDataProcessor::~MblMwDataProcessor() {
    delete state;
    state = nullptr;

    free(config);
    config= nullptr;

    if (remove) {
        uint8_t command[3]= { MBL_MW_MODULE_DATA_PROCESSOR, ORDINAL(DataProcessorRegister::REMOVE), header.data_id };
        send_command(owner, command, sizeof(command));
    }
}

int32_t response_handler_packed_data(MblMwMetaWearBoard *board, const uint8_t *response, uint8_t len) {
    try {
        ResponseHeader header(response[0], response[1]);
        auto signal = dynamic_cast<MblMwDataSignal*>(board->module_events.at(header));
        if (signal->handler == nullptr) {
            return MBL_MW_STATUS_WARNING_UNEXPECTED_SENSOR_DATA;
        }

        for(uint8_t i= 2; i < len; i+= CARTESIAN_FLOAT_SIZE) {
            MblMwData* data = data_response_converters.at(signal->interpreter)(false, signal, response + i, len - i);
            data->epoch= duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();

            signal->handler(data);

            free(data->value);
            free(data);
        }

        return MBL_MW_STATUS_OK;
    } catch (exception) {
        return MBL_MW_STATUS_WARNING_UNEXPECTED_SENSOR_DATA;
    }
}

MblMwMetaWearBoard::~MblMwMetaWearBoard() {
    logger_state.reset();
    timer_state.reset();
    event_state.reset();
    dp_state.reset();

    for (auto it: module_events) {
        it.second->remove= false;
        delete it.second;
    }

    for (auto it: module_config) {
        free(it.second);
    }
}

void mbl_mw_metawearboard_char_read(MblMwMetaWearBoard *board, const MblMwGattChar *characteristic, const uint8_t *value, uint8_t length) {
    if (characteristic->uuid_high == DEV_INFO_FIRMWARE_CHAR.uuid_high && characteristic->uuid_low == DEV_INFO_FIRMWARE_CHAR.uuid_low) {
        if (board->firmware_revision.empty()) {
            board->firmware_revision.assign(string(value, value + length));
            board->module_discovery_index= -1;
        } else {
            Version current;
            current.assign(string(value, value + length));

            if (board->firmware_revision == current) {
                if (mbl_mw_metawearboard_is_initialized(board)) {
                    board->initialized_timeout->cancel();
                    board->initialized(board, MBL_MW_STATUS_OK);
                } else {
                    board->module_discovery_index = MODULE_DISCOVERY_CMDS.size();
                    service_discovery_completed(board);
                }
                return;
            } else {
                board->logger_state.reset();
                board->timer_state.reset();
                board->event_state.reset();
                board->dp_state.reset();

                for (auto it : board->module_events) {
                    it.second->remove = false;
                    delete it.second;
                }
                board->module_events.clear();

                for (auto it: board->module_config) {
                    free(it.second);
                }
                board->module_config.clear();

                board->module_info.clear();
                board->module_discovery_index= -1;
            }
        }
        queue_next_gatt_char(board);
    } else if (characteristic->uuid_high == DEV_INFO_MODEL_CHAR.uuid_high && characteristic->uuid_low == DEV_INFO_MODEL_CHAR.uuid_low) {
        board->module_number.assign(value, value + length);
        queue_next_gatt_char(board);
    }
}

bool loadCinematic(Cinematic * c, const res::path & file) {
	
	LogInfo << "loading cinematic " << file;
	
	size_t size;
	char * data = resources->readAlloc(file, size);
	if(!data) {
		LogError << "cinematic " << file << " not found";
		return false;
	}
	
	bool ret = parseCinematic(c, data, size);
	free(data);
	if(!ret) {
		LogError << "loading cinematic " << file;
		c->New();
	}
	
	return ret;
}

//*************************************************************************************
//*************************************************************************************
// Removes a linked object Data field from an object
static void EERIE_LINKEDOBJ_Remove(EERIE_3DOBJ * obj, long num)
{
	if (obj == NULL) return;

	if (obj->linked == NULL) return;

	if (num < 0) return;

	if (num >= obj->nblinked) return;

	if (obj->nblinked == 1)
	{
		free(obj->linked);
		obj->linked = NULL;
		obj->nblinked = 0;
		return;
	}

	memcpy(&obj->linked[num], &obj->linked[num+1], sizeof(EERIE_LINKED)*(obj->nblinked - num - 1));
	obj->linked = (EERIE_LINKED *)realloc(obj->linked, sizeof(EERIE_LINKED) * (obj->nblinked - 1));
	obj->nblinked--;
}

/**
  <summary>
  Release a traversal object
  <summary>
  <param name="trav">The object to release</param>
  <remarks>
  The object must have been created with jsw_rbtnew
  </remarks>
*/
void jsw_rbtdelete ( jsw_rbtrav_t *trav )
{
  free ( trav );
}

/**
  <summary>
  Remove a node from a red black tree
  that matches the user-specified data
  <summary>
  <param name="tree">The tree to remove from</param>
  <param name="data">The data value to search for</param>
  <returns>
  1 if the value was removed successfully,
  0 if the removal failed for any reason
  </returns>
  <remarks>
  The most common failure reason should be
  that the data was not found in the tree
  </remarks>
*/
int jsw_rberase ( jsw_rbtree_t *tree, void *key )
{
  if ( tree->root != NULL ) {
    jsw_rbnode_t head = {0, NULL, NULL, {NULL,NULL}}; /* False tree root */
    jsw_rbnode_t *q, *p, *g; /* Helpers */
    jsw_rbnode_t *f = NULL;  /* Found item */
    int dir = 1;

    /* Set up our helpers */
    q = &head;
    g = p = NULL;
    q->link[1] = tree->root;

    /*
      Search and push a red node down
      to fix red violations as we go
    */
    while ( q->link[dir] != NULL ) {
      int last = dir;

      /* Move the helpers down */
      g = p, p = q;
      q = q->link[dir];
      dir = tree->cmp ( tree->type, q->key, key ) < 0;

      /*
        Save the node with matching data and keep
        going; we'll do removal tasks at the end
      */
      if ( tree->cmp ( tree->type, q->key, key ) == 0 )
        f = q;

      /* Push the red node down with rotations and color flips */
      if ( !is_red ( q ) && !is_red ( q->link[dir] ) ) {
        if ( is_red ( q->link[!dir] ) )
          p = p->link[last] = jsw_single ( q, dir );
        else if ( !is_red ( q->link[!dir] ) ) {
          jsw_rbnode_t *s = p->link[!last];

          if ( s != NULL ) {
            if ( !is_red ( s->link[!last] ) && !is_red ( s->link[last] ) ) {
              /* Color flip */
              p->red = 0;
              s->red = 1;
              q->red = 1;
            }
            else {
              int dir2 = g->link[1] == p;

              if ( is_red ( s->link[last] ) )
                g->link[dir2] = jsw_double ( p, last );
              else if ( is_red ( s->link[!last] ) )
                g->link[dir2] = jsw_single ( p, last );

              /* Ensure correct coloring */
              q->red = g->link[dir2]->red = 1;
              g->link[dir2]->link[0]->red = 0;
              g->link[dir2]->link[1]->red = 0;
            }
          }
        }
      }
    }

    /* Replace and remove the saved node */
    if ( f != NULL ) {
      f->key = q->key;
      f->data = q->data;
      p->link[p->link[1] == q] =
        q->link[q->link[0] == NULL];
      free ( q );
    }

    /* Update the root (it may be different) */
    tree->root = head.link[1];

    /* Make the root black for simplified logic */
    if ( tree->root != NULL )
      tree->root->red = 0;

    --tree->size;
  }

  return 1;
//.........这里部分代码省略.........

ConvexHull::~ConvexHull() {
    free(this->points);
}