Toll Free Numbers
  • Last 5 Forum Topics
    Last post

The Web Only This Site



  • MARC

    Mailing list ARChives
    - Search by -


    Computing Dictionary

  • Text Link Ads
  • LINUX man pages
  • Linux Man Page Viewer

    The following form allows you to view linux man pages.





           #include <search.h>
           int hcreate(size_t nel);
           ENTRY *hsearch(ENTRY item, ACTION action);
           void hdestroy(void);
           #define _GNU_SOURCE         /* See feature_test_macros(7) */
           #include <search.h>
           int hcreate_r(size_t nel, struct hsearch_data *htab);
           int hsearch_r(ENTRY item, ACTION action, ENTRY **retval,
                         struct hsearch_data *htab);
           void hdestroy_r(struct hsearch_data *htab);


           The three functions hcreate(),  hsearch(),  and  hdestroy()  allow  the
           caller to create and manage a hash search table containing entries con-
           sisting of a key (a string) and associated  data.   Using  these  func-
           tions, only one hash table can be used at a time.
           The  three  functions  hcreate_r(), hsearch_r(), hdestroy_r() are reen-
           trant versions that allow a program to use more than  one  hash  search
           table at the same time.  The last argument, htab, points to a structure
           that describes the table on which the function is to operate.  The pro-
           grammer  should treat this structure as opaque (i.e., do not attempt to
           directly access or modify the fields in this structure).
           First a hash table must be created using hcreate().  The  argument  nel
           specifies  the  maximum  number of entries in the table.  (This maximum
           cannot be changed later, so choose it wisely.)  The implementation  may
           adjust  this  value  upward to improve the performance of the resulting
           hash table.
           The hcreate_r() function performs the same task as hcreate(),  but  for
           the  table  described by the structure *htab.  The structure pointed to
           by htab must be zeroed before the first call to hcreate_r().
           The function hdestroy() frees the memory occupied  by  the  hash  table
           that was created by hcreate().  After calling hdestroy() a new hash ta-
           ble can be created using hcreate().  The hdestroy_r() function performs
           the  analogous task for a hash table described by *htab, which was pre-
           viously created using hcreate_r().
           The hsearch() function searches the hash table for  an  item  with  the
           same  key as item (where "the same" is determined using strcmp(3)), and
           if successful returns a pointer to it.
           insert a copy of item (and return a pointer to the new hash table entry
           as the function result), or the value FIND, meaning that NULL should be
           returned.  (If action is FIND, then data is ignored.)
           The hsearch_r() function is like hsearch() but operates on the hash ta-
           ble   described  by  *htab.   The  hsearch_r()  function  differs  from
           hsearch() in that a pointer to the found item is returned  in  *retval,
           rather than as the function result.


           hcreate()  and hcreate_r() return nonzero on success.  They return 0 on
           error, with errno set to indicate the cause of the error.
           On success, hsearch() returns a pointer to an entry in the hash  table.
           hsearch()  returns  NULL  on error, that is, if action is ENTER and the
           hash table is full, or action is FIND and item cannot be found  in  the
           hash  table.   hsearch_r()  returns nonzero on success, and 0 on error.
           In the event of an error, these two functions set errno to indicate the
           cause of the error.


           hcreate_r() and hdestroy_r() can fail for the following reasons:
           EINVAL htab is NULL.
           hsearch() and hsearch_r() can fail for the following reasons:
           ENOMEM action  was ENTER, key was not found in the table, and there was
                  no room in the table to add a new entry.
           ESRCH  action was FIND, and key was not found in the table.
           POSIX.1-2001 specifies only the ENOMEM error.


       Multithreading (see pthreads(7))
           The hcreate(), hsearch(), and hdestroy() functions use a  global  space
           for storing the table, so they are not thread-safe.
           The  hcreate_r(),  hsearch_r(),  and hdestroy_r() functions are thread-


           The functions hcreate(), hsearch(), and hdestroy() are from  SVr4,  and
           are described in POSIX.1-2001.  The functions hcreate_r(), hsearch_r(),
           and hdestroy_r() are GNU extensions.


           Hash table implementations are usually more efficient  when  the  table
           contains  enough  free  space  to minimize collisions.  Typically, this
           means that nel should be at least 25% larger than the maximum number of
           elements that the caller expects to store in the table.
           mentation  violates  the specification, updating the data for the given
           key in this case.
           Individual hash table entries can be added, but not deleted.


           The following program inserts 24 items into a hash table,  then  prints
           some of them.
           #include <stdio.h>
           #include <stdlib.h>
           #include <search.h>
           static char *data[] = { "alpha", "bravo", "charlie", "delta",
                "echo", "foxtrot", "golf", "hotel", "india", "juliet",
                "kilo", "lima", "mike", "november", "oscar", "papa",
                "quebec", "romeo", "sierra", "tango", "uniform",
                "victor", "whisky", "x-ray", "yankee", "zulu"
               ENTRY e, *ep;
               int i;
               for (i = 0; i < 24; i++) {
                   e.key = data[i];
                   /* data is just an integer, instead of a
                      pointer to something */
          = (void *) i;
                   ep = hsearch(e, ENTER);
                   /* there should be no failures */
                   if (ep == NULL) {
                       fprintf(stderr, "entry failed\n");
               for (i = 22; i < 26; i++) {
                   /* print two entries from the table, and
                      show that two are not in the table */
                   e.key = data[i];
                   ep = hsearch(e, FIND);
                   printf("%9.9s -> %9.9s:%d\n", e.key,
                          ep ? ep->key : "NULL", ep ? (int)(ep->data) : 0);

  • Linux

    The Distributions


    The Software


    The News


  • Toll Free

Toll Free Numbers
Copyright © 1999 - 2016 by LinuxGuruz