Abstract: Error handling and cleanup work is especially important for the development of the Symbian OS environment. Error Handle is actually to write a more reliable program, and the cleanup framework is the programming foundation of the Symbian OS. Because of this, it is necessary to ensure that the error handling and cleaning are very effective and easy to implement.
OOM (OUT-of-Memory) Errors have to talk in the Symbian OS environment. The current desktop memory has a larger capacity, plus virtual memory created on a larger hard disk, and users may perform regular restarts. In this case, the memory consumption rarely occurs. In the case of Symbian OS, RAM is less than 4MB, which generally does not exceed 16MB, often requires not to restart when used. So we have developed in the Symbian OS environment to pay attention to the following questions:
It is necessary to programmatically, so that the program will not waste RAM. Resources must be released as soon as possible, because the resources are not released, allowing the running program to consume more and more RAM. There must be short-memory error errors. Such errors in the Symbian OS can occur randomly. If there is a lack of memory, some operations are stopped, and user data must not be lost. If a memory is insufficient in an operation to allocate a number of resources, you must clean up all of these resources.
In fact, Symbian OS's error handling and cleaning framework is not only valid for OOM errors, many other operations may fail because their environmental conditions may fail, such as read and write files, open files, and transmit and accept data in communication sessions. You can also use the error handling and cleanup framework.
The following is a tool to handle insufficient memory and test OOM:
The most common debugger common CTRL Alt Shift (A uses a stack unit, B file server resource, C Window Server Resources) Pile Check tool, to check if the resource allocated by the function releases the C destructor to destroy the object heap Failure tool, deliberately generate error exception exit mechanisms, used to indicate an error. One of the basic functions User :: Leave () cleaning stack is ready to capture an abnormal exit process, similar to the Try-Catch mechanism in C CBase class, all CAT base classes of all CATs, by the cleaning stack, including A C destructor two-stage constructor naming agreement
The tools described above will be described in some introduction: Heap Check: Mainly using macro _uheap_mark and _uheap_markend. Macro _UHEAP_MARKEND is mainly called in the destructuring function. At this time, if there is any position in the program, if the macro _uheap_mark is included, it can be checked whether the middle stack operation is balanced, that is, if the number of stack units is different, the number is different, The program will be wrong. The destructor is not stranger, just simply brings the object used in the program, not all to release it in the destruction function, which is just the object you own, and does not include temporary generation. Local variable. Pile failure tool This tool is mainly used to handle insufficient memory. There is an application named MemoryMagic is this role, but not all Symbian systems have corresponding use of this application. Specific use can be downloaded on Symbian's official website. This stuff has a corresponding instruction manner. The abnormality exit mechanism is of course using user :: leave () to exit according to different error codes (see the Symbian error code in this blog) exception, the user :: leave () function can stop the running of the active function and then terminate All call functions. Cleaning stack cleaning stack is solved as follows: Cleaning stacks allocated on the heap, but pointing to its unique pointer is an object of automatic variable. If the function of the assigned object is abnormally exiting, you need to clean the object. Routines Case Emagiccmd: {CX * X = New (Eleave) CX; Cleanupstack :: Pushl (x); x> user (); cleanupstack :: popandDestroy (x);} The above routine is not usual The program can be properly exited because all objects on the cleaning stack are elapsed as part of an abnormal process. Of course, you can also do Case Emagiccmd: {CX * X = New (Eleave) CX; Trapd (Error, X> User ()); if (error) {Delete X; user :: leave (error);} delete X; Generally, members variables are often destroyed by the destruction functions of the class, so they do not push member variables into the cleaning stack, avoid twice deletion!
Two-stage construct cleaning stacks are used to save pointers that point to a heap-based object to clean up when an abnormality exits. This means that there must be an opportunity to push the object into the cleaning stack. This issue can be solved by two phases.
First, please remember that the C constructor should not contain any function that may be abnormally exited. Routines: Class Cy: Public CBase {public: Cy (); ~ cy (); public: cx * ix; cy: cy: cy: {ix = new (elefee) cx;} cy: ~ cy () {Delete IX ;}} CY * Y = new (elefee) cy; cleanupstack :: pushl (y); ... cleanupstack :: popandDestroy (y); This time is in the process of assigning CY, at the same time, to assign a CX, due to construct Function Cy () has no abnormal processing mechanism, so once the CX fails, you get a memory leak error, so you need to use a completely independent function to implement this. So I defined ConstructL () Class Cy: Public CBase {public: ~ cy (); static cy * newl (); static cycluctl (); void constructL (); public: cx * ix; cy: ~ cy: ~ cy: ~ CY ( ) {delete ket;}} void cy: constructL () {ix = new (eleive) cx;} Call is changed to: CY * Y = new (eleven) cy; cleanupstack :: pushl (y); y-> constructl ); ... Cleanupstack :: PopandDestroy (Y); It is clear that constructL () can be securely cleaned up.
Some empirical bars: objects are not assigned twice, and cannot be deleted twice. DELETE IB; / / Plus IB = NULL; / / Plus IB = New CB; Do not delete non-owned objects Never exit from the C constructor. Use your naming specifications to help you understand the program. Use well the stack. Use a good macro trapd () with user: leave (). -------------------------------------------------- --------- In short, the error handling and cleaning under Symbian OS are abnormal and difficult to ponder. Only we will slowly overcome it with our carefulness.
- Feng Xiao Yun original
