Fundamental Data Type

Chapter 12

Number Don't use "magic numbers", use "defined" constants

int Array[100] vs. int size = 100;   int Array[size] for i = 0 to 99 do ... vs. for i = 0 to MAX_ENTRIES-1 do ...

Use hard-coded 0s and 1s if you need to for i = 0 to CONSTANT do ... total = total + 1

Anticipate divide-by-zero errors Make type conversions obvious

y = x + (float) I Avoid mixed-type comparisons

If x is a floating-point number and i is an integer, the following test is almost guaranteed not to work.

if ( i = x ) then ... Heed your compiler's warnings

   

Integers Check for integer division

7/10 does equal 0.7? Check for integer overflow

overflow is always silent 16 bit --> (-32768, + 32767)   or unsigned is 65536 250 * 300=75,000. But if the maximum integer is 65,535, the answer you'll get is

probably 9464 because of integer overflow (75,000 - 65,536 = 9464).

Check for overflow in intermediate results

Why?Limit (unsigned 16bits): 65535 or 1111 1111 1111

1111

Too big: 65536 or 1 0000 0000 0000 0000

What's stored: 0 or 0000 0000 0000 0000stored = value % (limit + 1) or 65536 % (65535 + 1) = 0

Positive limit(signed 16bits): 32767 or 0111 1111 1111 1111

Too big: 32768 or 1000 0000 0000 0000

What's stored: -32768 1000 0000 0000 0000 0111 1111 1111 1111 (2’s compliment)+ 1 1000 0000 0000 0000

Floating-Point Numbers Around problem:

With a 32-bit floating-point variable, 1,000,000.00 + 0.1 =1,000,000.00

because 32 bits don't give you enough significant digits to encompass the range between 1,000,000 and 0.1.

Likewise, 5,000,000.02 - 5,000,000.01 is probably 0.0. Solutions?

Avoid additions and subtractions on numbers that have greatly different magnitudes

If you have to add a sequence of numbers that contains huge differences like this, sort the numbers first, and then add them starting with the smallest values.

if you need to sum an infinite series, start with the smallest term—essentially, sum the terms backwards.

This doesn't eliminate round-off problems, but it minimizes them.

Avoid equality comparisons

Solution

Characters and Strings Avoid magic characters and strings Use named constants and CONSTANT + 1 for string

allocations eg. char Name[16]; //bad

#define NAME_LENGTH 15 char Name[NAME_LENGTH + 1]  (add 1 for '\0' character)

always initialize strings to something if nothing else fits, create a NULL string char String[50] = ""

use calloc rather than malloc calloc also initializes the acquired memory to 0x00 in C++, always use new for class objects so that

constructors are involve

Characters and Strings –cont’ use strncpy instead of strcpy use strncmp instead of strcmp

both of the above commands have an extra parameter that specifies the maximum length of the arguments

Boolean Variables use them as self-documenting code

        eg. if(SearchDone)        eg. if(InputEnd)

use them to split complicated conditional expressions into simpler terms        eg. InputEnd = feof( ) || ferror( ) ...;             ....            if (InputEnd || ..... ||.....) ...

Enumerated Types Enumerated types are a powerful alternative

to shopworn schemes “1 stands for red, 2 stands for green, 3 stands for

blue…." This ability suggests several guidelines for using

enumerated types: Use enumerated types for readability

if chosenColor = 1you can write more readable expressions like

if chosenColor = Color_Red

Enumerated Types –cont’ Use enumerated types for reliability

With named constants, the compiler has no way of knowing that the only legal values are Color_Red, Color_Green, and Color_Blue.

The compiler won't object to statements like color = Country_England or country = Output_Printer.

If you use an enumerated type, declaring a variable as Color, the compiler will allow the variable to be assigned only the values Color_Red, Color_Green, and Color_Blue

Use enumerated types for modifiability If you discover a flaw in your "1 stands for red, 2 stands for

green, 3 stands for blue" scheme, you have to go through your code and change all the 1s, 2s, 3s, and so

on. If you use an enumerated type,

you can continue adding elements to the list just by putting them into the type definition and recompiling.

Enumerated Types –cont’ Use enumerated types as an alternative to boolean

variables For example, suppose you have a routine

Return true = successfully performed its task Return false = otherwise. Later you might find that you really have two kinds of False.

False 1= the task failed and the effects are limited to the routine itself;

False 2= the task failed and caused a fatal error that will need to be propagated to the rest of the program.

an enumerated type with the values Status_Success, Status_Warning, and Status_FatalError would be more useful than a boolean with the values true and false.

This scheme can easily be expanded to handle additional distinctions in the kinds of success or failure.

Enumerated Types –cont’ Check for invalid values When you test an enumerated type in an if or

case statement, check for invalid values. Use the else clause in a case statement to

trap invalid values:

Enumerated Types –cont’ If your language doesn't have enumerated types, You can simulate

them with global variables or classes. For example, you could use these declarations in Java:

Named Constants

Arrays bounds check use arrays sequentially rather than randomly

random accesses in arrays are similar to random gotos in a program

such accesses tend to be undisciplined, error prone, and hard to prove correct.

consider using container classes watch subscript order on multidimensional

arrays Array[i][j] vs Array[j][i] //order! Using meaningful name for i and j

container classes example        class SafeArray{

                private:                    enum (size = 100);                    int Array[size];                    .....                public:                    int & operator [ ] (int n);                    {                        if (n<size)                            return Array[n];                        else                            .... do something dramatic...                    }            }

Pointer C++ Pointer usage is one of the most error-prone

areas of modern programming modern languages like Java, C#, and Visual

Basic don't provide a pointer data type. Using pointers is inherently complicated, and

using them correctly requires that you have an excellent understanding of your compiler's memory-management scheme.

Many common security problems, especially buffer overruns, can be traced back to erroneous use of pointers

Pointer C++ Paradigm for Understanding Pointers (two parts: )

a location in memory a knowledge of how to interpret the contents of that

location Location in Memory

the location in memory is an address expressed in hexadecimal notation an address on a 32-bit processor would be a 32-bit value,

0x0001EA40. the pointer itself contains only this address If you were to look at the memory in that location, it

would be just a collection of bits. It has to be interpreted to be meaningful.

Pointer C++ Knowledge of How to Interpret the Contents

interpret the contents of a location in memory is provided by the base type of the pointer.

If a pointer points to an integer the compiler interprets the memory location given by

the pointer as an integer. you can have an integer pointer, a string pointer, and a

floating-point pointer all pointing at the same memory location. only one of the pointers interprets the contents at that

location correctly.

The amount of memory used by each data type is shown by double lines

Tips on Pointers Declare and define pointers at the same time

Tips on Pointers –cont’ Use extra pointer variables for clarity

It's hard enough to figure out what someone is doing with a linked list without having to figure out why one genericLink variable is used over and over

again or what pointer->next->last->next is pointing at.

Tips on Pointers –cont’ Draw a picture

Code descriptions of pointers can get confusing. It usually helps to draw a picture.

Tips on Pointers –cont’ Set pointers to null after deleting or freeing them

A common type of pointer error is the "dangling pointer," use of a pointer that has been delete'd or free'd.

By setting pointers to null after freeing them, you don't change the fact that you can read data pointed to by a dangling pointer.

But you do ensure that writing data to a dangling pointer produces an error.

Tips on Pointers –cont’ Simplify complicated pointer expressions

complicated pointer expressions are hard to read if your code contains expressions like p->q->r-

>s.data think about the person who has to read the

expression

C++-Pointer Pointers The difference between pointers and

references in C++, both pointers (*) and the references (&)

refer indirectly to an object. to the uninitiated the only difference appears to

be a purely cosmetic distinction between referring to fields as object->field vs. object.field.

the most significant differences are that a reference must always refer to an object, a pointer can point to null

what a reference refers to can't be changed after the reference is initialized.

C++-Pointer Pointers Use pointers for "pass by reference"

parameters and use const references for "pass by value" parameters C++ defaults to passing arguments to routines by

value rather than by reference. When you pass an object to a routine by value, C+

+ creates a copy of the object, and when the object is passed back to the calling routine, a copy is created again.

For large objects, that copying can eat up time and other resources.

Consequently, when passing objects to a routine, you usually want to avoid copying the object, which means you want to pass it by reference rather than by value.

C++-Pointer Pointers – cont’ Sometimes, however, you would like to have

the semantics of a pass by reference the passed object should not be altered

the implementation of a pass by value passing the actual object rather than a copy