🚀 go-pugleaf

William White (wcw@wolfe.net) wrote:
: 	Is it better to free all allocated memory from new & malloc()...  by freeing 
: it with a #pragma exit function, or a regular function just before exit() is 
: called?  Using the #pragma exit way, I've been getting some lockup in my 
: program... :(

   Stay away from pragma exit...   You are better off using atexit()
functions.  it's supported by ANSI.
   You are missing the poiont of dynamic allocation if you were to
allocate memory and never release it until program ends.  You are better
of using hard coded array.

:         ---Will
: +----------------------------------------------------------------------+
: |     William White ®¯ Yakima, WA. ®¯ Hi-Country Foods Corporation     |
: |    Quality Assurance Lab Technician ®¯ Computer Analyst/Programmer   | 
: |             ** We make it, you drink it, you love it **              |
: |Check out our new web page at http://www.wolfe.net/~hcfoods/index.html|
: |       For my Public PGP key, please finger me at wcw@wolfe.net       |
: +----------------------------------------------------------------------+

On 5 Sep 1995, William White wrote:

> 	Is it better to free all allocated memory from new & malloc()...  by freeing 
> it with a #pragma exit function, or a regular function just before exit() is 
> called?  Using the #pragma exit way, I've been getting some lockup in my 
> program... :(

#pragma exit (or #pragma _anything_) is non-portable.

  When you're programming in C, deallocate all malloc()'d memory with 
the "regular" Standard Library function free().
  In C++, use the "regular" keyword delete to destroy all objects you 
allocate with new.

  *Never* mix new and malloc(), or delete and free(), in the same 
program.  They are *not* guaranteed to cooperate, and since they belong 
to two different languages there's no reason that they should.

___________
Bushido, n.: the ancient art of keeping your  | James Robinson
cool when a US President ralphs in your lap.  | james-f-robinson@uiowa.edu

wcw@wolfe.net (William White) writes:

>	Is it better to free all allocated memory from new &
>malloc()...  by freeing it with a #pragma exit function, or a regular
>function just before exit() is called?  Using the #pragma exit way,
>I've been getting some lockup in my program... :(


The #pragma is inherently non-portable. The OS should free all of the
memory you malloc'd or new'd, although it is wise to be more careful
with memory management if the program is to have long termporal
existence.

// DQG.


--
+------------------------------------------------------------------------+
| Derick R. Qua-Gonzalez                                      | ________ |
| Department of High Energy Physics, Cal State University     | \      / |
| dqua@dqua.EarthLink.Net                                     |  \    /  |
|     ``It is better to be hated for what one is,             |   \  /   |
|       than loved for what one is not.'' (A. Gide)           | G  \/ USA|
+-------------------------------------------------------------+----------+

In article <42hdl3$rkr@ratty.wolfe.net>, William White <wcw@wolfe.net> wrote:
>	Is it better to free all allocated memory from new & malloc()...  by freeing 
>it with a #pragma exit function, or a regular function just before exit() is 
>called?  Using the #pragma exit way, I've been getting some lockup in my 
>program... :(

Don't call library functions in any #pragma exit registered functions.

As to freeing the memory, if you're program ends already there is really
no need to start freeing memory shortly before that.  Simply exiting the
program will free the memory afterward.