Fundamental Data Type - PowerPoint PPT Presentation

Fundamental data type
1 / 41

  • Uploaded on
  • Presentation posted in: General

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 ...

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

Download Presentation

Fundamental Data Type

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Fundamental data type

Fundamental Data Type

Chapter 12



  • 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



  • 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

Fundamental data type


stored = value % (limit + 1) or 65536 % (65535 + 1) = 0

1000 0000 0000 0000

0111 1111 1111 1111 (2’s compliment)

+ 1

1000 0000 0000 0000

Floating point numbers

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

Avoid equality comparisons



Characters and strings

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

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

Boolean Variables

  • use them as self-documenting codeeg. if(SearchDone)eg. if(InputEnd)

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

Enumerated types

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

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 cont1

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 cont2

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 cont3

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

Named Constants



  • 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

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 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 c1

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 c2

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.

Fundamental data type

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

Tips on pointers

Tips on Pointers

  • Declare and define pointers at the same time

Tips on pointers cont

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 cont1

Tips on Pointers –cont’

  • Draw a picture

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

Tips on pointers cont2

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 cont3

Tips on Pointers –cont’

  • Simplify complicated pointer expressions

    • complicated pointer expressions are hard to read

    • if your code contains expressions like p->q->r->

    • think about the person who has to read the expression

C pointer pointers

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 pointers1

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

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

  • Login