Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out

declarations

VIEWS: 24 PAGES: 14

									Programming


      Declarations
COMP102 Prog. Fundamentals I: Declarations/ Slide 2




            General form of a C++ program
                // Program description
                #include directives
                int main(){

                       constant declarations

                       variable declarations

                       executable statements
                       return 0;
                 }
COMP102 Prog. Fundamentals I: Declarations/ Slide 3




                                     C++ Data Type
           A type defines a set of values and a
           set of operations that can be applied on
           those values. The set of values for each
           type is known as the domain for the type.
           C++ contains 5 standard types:
                                             Standard
                                            Data Types


           void                    int                char   float   bool
COMP102 Prog. Fundamentals I: Declarations/ Slide 4




                                                      void


            The void type has no values and no
            operations. In other words, both the set
            of values and the set of operations are
            empty. Although this might seem unusual,
            we will see later that it is a very
            useful data type.
COMP102 Prog. Fundamentals I: Declarations/ Slide 5




                                                      Integer
  An integer type is a number without a
  fractional part. It is also known as an
  integral number. C++ supports three different
  sizes of the integer data type: short int, int
  and long int.

     sizeof(short int)<= sizeof(int)<= sizeof(long int)


                                                      Short int
                                                         int
                                                        long int
COMP102 Prog. Fundamentals I: Declarations/ Slide 6




                                                      Integer
           The type also defines the size of the field in which data can
           be stored. In C++, even though the size is machine
           dependent, most PCs use the integer sizes shown below.

     Type                Sign                   Byte Number Min Value Max Value
                                                Size of Bits
     short int           Signed                 2       16      -32768           32767
                         unsigned                                    0           65535
                                                                -2,147,483,648   2,147,483,647
     int                 Signed                 4       32
                         unsigned                                           0    4,294,967,295

                                                                -2,147,483,648   2,147,483,647
     long int            Signed                 4       32
                                                                                 4,294,967,295
                         unsigned                                           0
COMP102 Prog. Fundamentals I: Declarations/ Slide 7




                                       Floating Point
  A floating-point type is a number with a
  fractional part, such as 43.32. The C++
  language supports three different sizes of
  floating-point: float, double and long double.

   sizeof(float)<= sizeof(double)<= sizeof(long double)



                                                       float
                                                      double
                                                      long double
COMP102 Prog. Fundamentals I: Declarations/ Slide 8




                                       Floating Point
                  Although the physical size of floating-point types is
                  machine dependent, many computers support the
                  sizes shown below.

                type                            Byte size   Number of Bits


                float                           4           32

                double                          8           64

                long double                     10          80
COMP102 Prog. Fundamentals I: Declarations/ Slide 9




                                         Declarations
          Constants and variables must be declared before they
           can be used.
          A constant declaration specifies the type, the name and
           the value of the constant.
          A variable declaration specifies the type, the name and
           possibly the initial value of the variable.
          When you declare a constant or a variable, the compiler:
          1. Reserves a memory location in which to store the
              value of the constant or variable.
          2. Associates the name of the constant or variable with
              the memory location. (You will use this name for
              referring to the constant or variable.)
          For more on declarations, see www.courseware.ust.hk
           and choose English--> C++ --> Declarations.
COMP102 Prog. Fundamentals I: Declarations/ Slide 10




                           Constant declarations
     Constants are used to store values that never change
      during the program execution.
     Using constants makes programs more readable and
      maintainable.
     Syntax:
        const <type> <identifier> = <expression>;
      Examples:
        const double US2HK = 7.8;
                         //Exchange rate of US$ to HK$
        const double HK2TW = 3.98;
                         //Exchange rate of HK$ to TW$
        const double US2TW = US2HK * HK2TW;
                         //Exchange rate of US$ to TW$
COMP102 Prog. Fundamentals I: Declarations/ Slide 11



                          Variable declarations
       Variables are used to store values that can be changed
        during the program execution.
       A variable is best thought of as a container for a value.
                         3445       y      -3.14
     Syntax:
                    < type > < identifier >;
                    < type > < identifier > = < expression >;
     Examples:
            int sum;
            int total = 3445;
            char answer = 'y';
            double temperature = -3.14;
COMP102 Prog. Fundamentals I: Declarations/ Slide 12




                          Variable declarations
            A variable has a type and it can contain only values of
             that type. For example, a variable of the type int can
             only hold integer values.
            Variables are not automatically initialized. For example,
             after declaration
                  int sum;
             the value of the variable sum can be anything (garbage).
            Thus, it is good practice to initialize variables when they
             are declared.
            Once a value has been placed in a variable it stays
             there until the program deliberately alters it.
COMP102 Prog. Fundamentals I: Declarations/ Slide 13




                                    Character data
     A variable or a constant of char type can hold an
      ASCII character (see Appendix A of the textbook).
     When initializing a constant or a variable of char
      type, or when changing the value of a variable of
      char type, the value is enclosed in single quotation
      marks.

   Examples:
      const char star = '*';
      char letter, one = '1';
COMP102 Prog. Fundamentals I: Declarations/ Slide 14




                           Computers are Easy!

           "Using a computer is just like
            riding a bike, except you don't
            have to wear the tight shorts
            and funny helmet. A water
            bottle is also a bad idea. Just
            about everyone agrees that
            computing is very simple, or
            will be in only a few more
            days.
                                        – David Lubar, 1995

								
To top