Comp5421 object oriented programming
This presentation is the property of its rightful owner.
Sponsored Links
1 / 57

Comp5421 Object Oriented Programming PowerPoint PPT Presentation


  • 64 Views
  • Uploaded on
  • Presentation posted in: General

Comp5421 Object Oriented Programming. A Simple Example of Object-Oriented Design Lecture 2 Tianxiang(Tim) Shen Summer 2002 Department of Computer Science Concordia university. Object-Oriented Design.

Download Presentation

Comp5421 Object Oriented Programming

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


Comp5421 object oriented programming

Comp5421 Object Oriented Programming

A Simple Example of

Object-Oriented Design

Lecture 2

Tianxiang(Tim) Shen

Summer 2002

Department of Computer Science

Concordia university

Concordia TAV 2002 Comp5421_2


Comp5421 object oriented programming

Object-Oriented Design

  • Understanding the problem and the potential solution is a necessary starting point for a successful design.

  • Object-oriented design is fundamentally a three-step process:

    • Identifying the Classes

    • Characterizing the Classes

    • Defining the Implementation

  • Evaluating a Design

Concordia TAV 2002 Comp5421_2


Knight tour problem

Knight Tour Problem

Knight tour (KT) is a classic search problem:

Consider a k by k board of squares and a chess piece called a knight. A knight

in chess makes a move consisting either of two squares in a horizontal direction

followed by one in a vertical direction or two squares in a vertical direction

followed by one in a horizontal, as seen in Figure 2-1. A move in this sense

conveys the knight from one square on the board to another. A "knight's tour" is

a sequence of moves such that each square on the board is visited by the knight

exactly once and the knight ends up in the square where it started,

as in Figure 2-2. That is, the knight must visit each square of the board as part

of its tour and must not visit any square (other than its starting one ) more than

once. Your task is to write a program inputting k, the size of the board, and

outputting a valid tour if there is one or a message if there is not. The tour should

be output by showing a view of the board with each square. labeled with the

index of that move on a valid tour. An example of possible output is shown in

Figure 2-2.

Concordia TAV 2002 Comp5421_2


Understanding problem

Understanding Problem

Figure 2-1 The legal moves of the knight in chess:

Concordia TAV 2002 Comp5421_2


Understanding problem1

Understanding Problem

Inputting and outputting:

Figure 2-2

Concordia TAV 2002 Comp5421_2


Understanding problem2

Understanding Problem

  • Task is to write a program:

    Input:size of the board,

    Output: a valid tour with each square labeled with the index of its move, or

    a message if there is no KT.

  • Move consisting:

    1. two squares in a horizontal direction, one square in vertical direction, or

    2. two squares in a vertical direction, one square in horizontal direction.

  • Valid tour: Knight starts at a square, follows a path without visiting any square twice, and ends up where it started.

Concordia TAV 2002 Comp5421_2


Comp5421 object oriented programming

Exploring Potential Solution

  • Knight tour is a classic search problem. Considering all possibilities will not yield a practical solution. Why?

Concordia TAV 2002 Comp5421_2


Exploring potential solution

Exploring Potential Solution

  • Model KT search problem as a general tree:

    1.Root corresponds to the start cell.

    2. Number of 1st level nodes of tree corresponds to the number of the moves from start cell.

    3. Second move from each of these cells leads to further nodes, and so on.

    4. Degree of each node corresponds to the number of moves from its corresponding cell, it varies from 2 to 8.

  • Consider k=8 and 4 alternatives per move (average), the number of possible solutions will be 464. It will take forever!

Concordia TAV 2002 Comp5421_2


Exploring potential solution cont

Exploring Potential Solution (cont.)

  • Searching Result:

    1. Suppose there are N nodes in the path from root to the node that corresponds to one cell.

    2. From last node, one starting node may be reached:

    if N = k2

    then

    KT is found

    else

    the path failed for KT.

Concordia TAV 2002 Comp5421_2


Exploring potential solution cont1

Exploring Potential Solution (cont.)

  • Two principal Ways to explore a search tree:

    1. Depth first search (DFS):

    Follow a path until either find a solution, or

    get stuck.

    2. Breadth firstsearch (BFS):

    Visit all the vertexes at distance 1 from root, then all the vertexes at distance 2 from root, and so on.

Concordia TAV 2002 Comp5421_2


Exploring potential solution cont2

Exploring Potential Solution (cont.)

  • Depth first search:

    1. Put visited vertexes into a stack (last-in-first-out)

    2. More efficient in space because only vertexes on the path are stored in the stack;

  • Breath first search:

    1. Put visited vertexes into a queue (first-in-first-out);

    2. More space than DFS because the queue must contain all vertexes on the current path but usually contain other vertexes as well;

  • DFS may fail to terminate (if tree contain infinite path), but BFS always succeeds to complete the search.

Concordia TAV 2002 Comp5421_2


Exploring potential solution cont3

Exploring Potential Solution (cont.)

  • Methods of making choices:

    • systematic: explore the paths in some organized way.

      For KTs, we could try knight's moves in the following order: up-left, left-up, left-down, and so on, going clockwise.

      If a move is impossible, because it leads to a previously-visited cell or off the board, we try the next one.

    • Random: use a random-number generator to explore the path

Concordia TAV 2002 Comp5421_2


Comp5421 object oriented programming

Exploring Potential Solution (cont.)

  • Methods of making choices:

    • Heuristics: are experimental approaches to solving a given problem. They provide a set of guidelines that, while not guaranteed to be the best, is likely to yield a good solution.

    • Search heuristics such as we use here are guidelines on how best to perform the search. They provide a set of rules specifying what to look at next. The order specified by the rules is not necessarily the fastest or the best, but we hope it is good enough and fast enough for our purposes.

    • Heuristics are needed for KT because it is difficult or impossible to determine an algorithm to find a tour without doing any searching. This is characteristic of many complex problems.

Concordia TAV 2002 Comp5421_2


Exploring potential solution cont4

Exploring Potential Solution (cont.)

  • Backtracking is a good technique for exploring a search tree without repeating all over again, upon each failure.

    1. Start from root and build a path which contains choice points (several extensions).

    2. Continue making choices and building the path until success or getting stuck.

    3. If get stuck, move back to the most recent choice point and make a different choice.

    4. When have tried all choices at a particular choice point, move back further, and so on.

    5. If have backed up to the root and no further choice, there is no solution to the problem.

Concordia TAV 2002 Comp5421_2


Exploring potential solution cont5

Exploring Potential Solution (cont.)

  • Which cases have no solution? (observation)

    k  5, or k is odd number:

    k = 2, no knight’s move;

    k = 3, it cannot move to or from the center square;

    k = 4, 1,2,3,4 four cells form closed paths

Concordia TAV 2002 Comp5421_2


Exploring potential solution cont6

Exploring Potential Solution (cont.)

  • Which cases have no solution?

    K is odd number,

    it will not end up at the

    starting square after odd

    number of moves.

    because move must be

    form green to white, or white

    to green, and starts and ends on the same cell.

    It follows that a tour must visit an even number of cells, but

    the last move must be at the odd number of moves.

Concordia TAV 2002 Comp5421_2


Identifying candidate classes

Identifying Candidate Classes

  • Identifying potential class:

    1. Using problem statement;

    (1) Nouns represent objects and potential classes;

    (2) Verbs represent potential actions (methods of classes);

    (3) Adjectives represent properties of classes (private, public);

    2. Re-state the problem in your own terms;

    3. Analyze how a potential solution works and identify the items used in this solution that could quality as classes.

    Designer looks at scenarios, concrete cases of what the system would do for particular problems, rather than attempting to describe the genera solution.

    The set of classes involved in the scenario can be determined either by attempting to explain the scenario textually and extracting nouns and verbs from the text, or by listing the basic components of solution.

Concordia TAV 2002 Comp5421_2


Candidate classes

Candidate Classes

Concordia TAV 2002 Comp5421_2


Candidate classes cont

Candidate Classes (cont.)

  • Categories of Classes: (p23)

    Physical entities: Board, Knight, and Squares;

    Virtua1 entities: move sequence, set of legal moves from a square;

    Placeholder class is abstract interface to system components of the solution, either internal or external;

    Algorithm class represent internal aspect of the solution that are complex or not well understand, it is used to represent a potential solution;

    Heuristic class is used to encapsulate whatever heuristics are to be used (For KT, it is used to choose the next move),

    2nd algorithm class is used to represent the overall search process, it manages the search by finding next move, detecting success or failure of the search, and backtracking appropriately..

Concordia TAV 2002 Comp5421_2


Candidate classes cont1

Candidate Classes (cont.)

Concordia TAV 2002 Comp5421_2


Scenario of the potential solution

Scenario of the potential solution

  • The program reads in the size of the board, builds the board, finds a valid tour and then prints the resultant tour. We assume each square maintains the set of valid moves from that square as we build the tour. All legal knight moves from that square as are added to this set when the square is initialized. Assume we start and end in the upper left corner There are only two valid moves from this square, and the tours based on these moves are symmetric; we need consider only one of them. We identify the second square on the tour and remove its legal move to the starting corner. (This lets us find a valid tour by simply finding a sequence of moves covering all squares, since there is now only one way of getting to the starting square and hence it must be the last node of such a sequence.) Then we ask that second square to find a sequence of moves containing all unused squares starting at that square. Each square, when asked to find such a sequence, first updates the valid move lists of other squares, then uses some heuristic algorithm to order the list of valid moves so that the most likely to succeed is considered first. Then, for each move in the resultant order, it asks the next square to find the remaining sequence. If a square determines it can not continue a sequence, it restores the valid move lists and returns failure to its caller. If a square determines it has completed the tour, it returns the solution to its caller, which passes it back up to the top level.

Concordia TAV 2002 Comp5421_2


Choosing top level classes

Choosing Top-Level Classes

  • Top-Level classes perform a major role in the solution and interacts with other top-level classes in the significant ways.

  • Eliminate any candidate class if it is covered by other class.

  • Number of the top-level classes:

    1. Some system has only one top-level class,

    2. Large system may have as many as ten top-level classes,

    3. Proposed solution with 5-10 component, should fit pretty well into short-term memory and be easier to understand.

Concordia TAV 2002 Comp5421_2


Choose top level classes cont

Choose Top-Level Classes (cont.)

  • Top-level classes should be:

    1. Independent: their functions should not overlap;

    2. Balanced: work done by each class should be about the same;

    3. Interrelated: they must interact to solve the problem.

  • How to choose:

    1. Logical subset of potential classes should be grouped and a new class inserted in its place;

    2.Too large or too small classes should be either decomposed into subclasses or subsumed by another class.

Concordia TAV 2002 Comp5421_2


Choose top level classes cont1

Choose Top-Level Classes (cont.)

  • Here are the candidate classes that are not included in the final design:

    [Direction.] A direction is a (trivial) component of a Move.

    [Knight.] A Square represents the current position of the imaginary traveling knight.

    [Move.] A Square contains the set of valid moves. (This does not itself rule out the idea of a class Move. However, the amount of information contained in a move is small and does not warrant an extra class.)

    [Search.] Searching is performed by the Board class.

    [Tour.] This is essentially the same as the Solution class that we have included.

    [User Interface.] The class Main provides user interface services. However, we might decide later that the user interface is sufficiently important to be a separate class.

Concordia TAV 2002 Comp5421_2


Top level classes cont

Top-Level Classes (cont.)

Concordia TAV 2002 Comp5421_2


Top level classes cont1

Top-Level Classes (cont.)

Concordia TAV 2002 Comp5421_2


Characterizing the classes

Characterizing the Classes

  • Characterizing Classes:

    1.Description of what each class is,

    2.Description of what they can do (operation and relationship between them).

  • Textual design:

    Describing classes in terms of data, operations, and relationships, in order to help the designer understand them well.

    Data makes the class concrete

    Operation helps define what the designer thinks the class can do

    Relationship helps to show how this class fits in and clarifies the overall solution

Concordia TAV 2002 Comp5421_2


Characterizing the classes1

Characterizing the Classes

  • Skeleton declaration that shows important methods and attribute.

  • Main class represents the overall control process and implements the user interface.

    process operation reads the board size, sets up the board, does search, and prints the result

    class Main

    {

    public:

    void process();

    private:

    the_board

    int board_size;

    };

Concordia TAV 2002 Comp5421_2


Characterizing classes cont

Characterizing Classes (cont.)

  • Board class contains data member squares,

    it provides operations to set up the squares and to find the actual tour.

  • class Board

    { public:

    void setup ();

    void findTour ();

    private:

    squares };

Concordia TAV 2002 Comp5421_2


Comp5421 object oriented programming

Characterizing Classes (cont.)

  • Square class contains a square’s position (row and column) and the set of legal moves from that square

  • It sets up the square by defining the initial set of legal moves, and finds the remainder of a tour starting at this square.

  • class Square

  • { public:

    • void setup ();

    • void findRestOfTour ();

    • private:

    • int row_number;

    • int column_number;

    • legal_moves };

Concordia TAV 2002 Comp5421_2


Comp5421 object oriented programming

Characterizing Classes (cont.)

  • Heuristic class contains data, number of moves to consider

  • It provides method to order a set of moves to improve search time.

  • class Heuristic

  • {

  • public: void orderMoves ();

  • private:

  • };

  • Solution class contains a sequence of square indexes to hold the resultant tour

  • It accesses the solution so it can be output

  • class Solution

  • {

  • public:

  • void showSolution ();

  • private:

  • int* tour_index[MAX_MOVES]

  • };

Concordia TAV 2002 Comp5421_2


Characterizing classes cont1

Characterizing Classes (cont.)

  • The textual design lacks some of the information of the diagrammatic design. In particular, the text does not show interactions between classes.

  • The diagrams do show interaction between classes but they do not show which methods implement these interactions. If we annotated the class declarations to show how methods made use of other classes, the declarations would be more informative than the diagrams.

Concordia TAV 2002 Comp5421_2


Characterizing classes cont2

Characterizing Classes (cont.)

  • Static Structure Diagram

    (United Modeling Language):

  • Result:

    a high-level view of

    solution represented

    in terms of objects and

    interaction.

Concordia TAV 2002 Comp5421_2


Defining implementation

Defining Implementation

  • This is the final stage of OOD.

  • Designer's task is to ensure that each object is correct and the whole system can be made to work

  • The result of this phase should be a design that is a detailed enough that a programmer can implement each of the classes independently, put the implementations together, and achieve a working system.

  • The class definitions done in the previous stage should be taken as provisional.

  • It is important to find a stable starting point. In KT example, the starting point is the process operation of the class Main.

Concordia TAV 2002 Comp5421_2


Defining implementation1

Defining Implementation

  • Using Pseudocode to define implementation:

    1. Pseudocode is typically written as natural language structured as programming language, it is not a source code, However, it can reflect the target programming language,

    2. All information about class interaction must be represented precisely and completely, however it does not need to be told precisely how to implement a class, because the programmers know.

Concordia TAV 2002 Comp5421_2


Defining implementation cont

Defining Implementation (cont.)

  • Main Class: represent main flow of control.

    1.It is responsible for handling user interface (input and output).

    2.Set up all the other classes as needed to find the tour

    4.Print the tour

Concordia TAV 2002 Comp5421_2


Comp5421 object oriented programming

Main Class

  • The method Main::process controls the whole program. (Starting point)

  • void Main::process(int argc, const char ** argv)

    • {  Determine the board_size

      • Create a board

      • Set up the board by calling Board::setup(board_size)

      • If (tour exists for board size)

      • result_tour = Board::findTour()

      • Else result_tour = no_tour

      • Output the contents of result_tour

    • }

  • It is precise about its interaction with other classes. When an operation from another class is used, the code provides the full name and the arguments for that operation.This gives the designer the proper starting point for defining the implementation of that method.

  • It is vague when it refers to the internal implementation of the class Main.This vagueness provides the flexibility necessary to refine the class further. This type of information hiding is

  • essential in the design of larger systems.

  • Concordia TAV 2002 Comp5421_2


    Main class

    Main Class

    • Refined pseudocode for process method:

      void Main::process (int argc, const char **argv)

      {

      board_size = Main::getBoardSize(argc, argv);

      the_board = new Board;

      set up board by calling the_board->Board::setup(board_size);

      if (tour exists for board size)

      result_tour = Board::findTour();

      else

      result_tour = no_tour;

      Main::output(result_tour);

      }

    Concordia TAV 2002 Comp5421_2


    Comp5421 object oriented programming

    Main Class

    • Next step is to choose another method and provide the pseudocode for it.

    • Where possible, it is generally best to proceed with other methods of the same class first.

    • To simplify the program, use command line arguments and output the solution in the form of a board

    • int Main::getBoardSize(int argc, const char ** argv)

    • {Get board size from argv[1].

    • If not present, use 8.

    • Return board size.}

      • void Main::outputTour(Solution tour)

      • {If ! Tour->Solution::isValid() then Output message

      • Else

      • For row=0 to board_size -1

      • For col = 0 to board_size-1

      • I=tour->Solution::findIndex(row,col)

      • Output I using exactly 4 spaces

      • Next col

      • Output end of line

      • Next row

      • }

    Concordia TAV 2002 Comp5421_2


    Command line argument

    Command-line Argument

    • main function has two version:

      int main()

      int main(int argc, char *argv[])

      int main(int argc, char **argv) is equivalent to 2nd

    • Parameter argc holds the number of the command-line arguments, it is an integer.

      Parameter argv holds a pointer to these arguments, respectively.

      Ex. #include <iostream>

      using namespace std;

      int main(int argc, char *argv[])

      {

      cout <<"Received " << argc << " argumnets."<< endl;

      for (int i = 0; i <argc ; i++)// argv[1] or *(argv+1)

      cout << "atgument " << i << ": " << argv[i] << endl;

      return 0;

      }

    Concordia TAV 2002 Comp5421_2


    Command line argument cont

    Command-line Argument (cont.)

    Concordia TAV 2002 Comp5421_2


    Board class

    Board Class

    • Next define operations for either Board or Solution, since we have specified methods in both of these classes.

    • In this case, we should do Board first because all its incoming dependencies have been resolved, while Solution has a dependency from Board. One should try to define the classes in an order in which as much as possible is known about the class before any of its methods must be defined.

    • Data member:

      1. Integerboard_size;//size of the board

      2. Square *the_squares;//sq[bd_size][bd_size]

    Concordia TAV 2002 Comp5421_2


    Comp5421 object oriented programming

    Board Class

    • The operation Board::setup must define the board (using constructor). Its responsibilities include setting up the array of squares and initializing the squares:

    • void Board::setup(int size)

    • {

    • board_size = size

    • the_squares = new Square[size][size]

    • For row = 0 to size –1

    • For col =0 to size –1

    • the_squares->Square::setup(row, col)

    • Next col

    • Next row

    • }

    Concordia TAV 2002 Comp5421_2


    Board class1

    Board Class

    • Method Board::findTour must:

      specify the first move

      construct the resultant tour

      find the rest of the tour

    • Solution Board::findTour ()

      { Square start = squares[1][2];

      Square sq0 = squares[0][0];

      start->Square::markUsed(sq0);

      sq0->Square::markUsed(start);

      sol = new Solution;

      sol->Solution::setup(board_size);

      start->Square::findRestOfTour(sol);

      return sol;

      }

    • markUsed is used to remove the square (argument) from the set of valid moves of the base square

    • findRestOfTour is used to fill in the solution and return true if solution exists, false otherwise

    Concordia TAV 2002 Comp5421_2


    Comp5421 object oriented programming

    Board Class

    • findSquare method is used to return the valid square for valid row and col, otherwise return nothing(NULL)

    • Square Board::findSquare(int row,int col)

      • {

      •  If (row < 0 || row >= board_size) Return no square

      • If (col < 0 || col >= board_size) Return no square

      • Return squares[row][col]

      • }

    Concordia TAV 2002 Comp5421_2


    Comp5421 object oriented programming

    Square Class

    • Each square must keep track of the remaining legal moves from the square.

    • Data member:

    • 1. Integerrow_number;//row index

    • 2. Integercol_number;//col index

    • 3. Integernum_moves;//number of legal moves

    • 4. Squarelegal_moves[MAX_MOVES];//available moves

    • The initial set is defined by the setup operation

    • void Square::setup(Board board, int row, int col)

    • {row__number = row

    • col_number = col

    • num_moves = 0

    • For (x,y) in (-2,1-),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)

    • sq = board->Board::findSquare(row+x, col+y)

    • if (sq is valid)

    • legal_moves[num_moves] = sq

    • num_moves = num_moves +1

    • endif

    • Next (x,y)

    • }

    Concordia TAV 2002 Comp5421_2


    Square class

    Square Class

    • findRestOfTour is used to fill in the solution and return true if solution exists, false otherwise

    • Boolean Square::findRestOfTour(Solution sol)

      {sol->Solution::addSquare(row_number, column_number)//add this square to solution

      if(sol->isValid()) return True//check if done

      For each Move m from this square//remove moves to this square

      m->Square::markedUsed(this)

      Next m

      h = new Heuristic

      h->Heuristic::setup(num_moves, legal_moves)//try each move in turn

      while((sq = h->Heuristic::nextMove() ) != no square) do

      if (sq->Square::findRestOfTour(sol)) return true

      For each Move m from this square //restore moves to this square

      m->Square::unmarkUsed(this)

      Next m

      sol->Solution::removeSquare(row_number, column_number)

      //restore the board and fail

      return false

      }

    Concordia TAV 2002 Comp5421_2


    Square class1

    Square Class

    • markUsed is used to remove the square (argument) from the set of valid moves of the base square

      void Square::markUsed(Square sq)

      {

      remove sq from legal_moves and decrement num_moves

      }

    • void Square::unmarkUsed(Square sq)

      {

      legal_moves[num_moves] = sq

      num_moves = num_moves + 1

      }

    Concordia TAV 2002 Comp5421_2


    Heuristic class

    Heuristic Class

    • Class Heuristic is used to order the set of moves

      A simple heuristic is to look at the moves from the most to the least restrictive, i.e. select the next move with the minimum count

    • Data member:

      1. Integer num_moves

      2. Square valid_squares[8]

      3. Integer move_count[8]

    • Define an interface in which the heuristic object is set up for the given square by passing the num_moves and legal_moves

      Void Heuristic::setup(int num, Square moves[])

      //Using constructor to set up

    • Improve the simple heuristic by considering squares with no valid moves and unreachable sequences. (See next page)

    Concordia TAV 2002 Comp5421_2


    Comp5421 object oriented programming

    Heuristic Class

    • Improving version:

    • Void Heuristic::setup(int num, Square moves[])

    • {num_moves = num

    • numzero = 0

    • numone = 0

    • For i = 0 to num – 1

    • valid_square[ i ] = moves[ i ]

    • move_count[ i ] =valid_square[i] ->Square::numMoves()

    • if (move_count[i] ==1) numone =numone +1

    • if (move_count[i] == 0) numzero= numzero+1

    • Next i

    • if (numzero>1||(numzero==1 && num>1)) num_moves = 0

    • else if (numone>2) num_moves = 0

    • else if (numone>0)//i.e. numone = 1

    • Eliminate all the move but the move with move_count = 1

    • //move_count[i]=MAX_MOVES+1

    • //if single sequence, use only it

    • }

    Concordia TAV 2002 Comp5421_2


    Comp5421 object oriented programming

    Heuristic Class

    • NextMove method is used to return the next move square with minimum number of the squares

    • Square Heuristic::nextMove()

      • {

      • i = index of the remaining move with minimum move_count

      • If (there is no such i) Return no_square

      • move_count[i] = MAX_MOVES+1

      • Return valid_square[i]

    Concordia TAV 2002 Comp5421_2


    Solution class

    Solution Class

    • Solution class is used to hold the solution

    • Data member:

      • Integer board_size

      • Integer num_moves//size of current solution

      • Integer* tour_index//index[board_size*board_size]

    • Initialize the solution object

      void Solution::setup(int size)

      {

      tour_index = new Integer[size * size]

      For each i from 0 to size*size-1

      tour_index[i] = -1

      Next i

      num_moves = 0

      board_size = size

      }

    Concordia TAV 2002 Comp5421_2


    Solution class1

    Solution Class

    • Void Solution::addMove(int row, int col)

      {tour_index[row][col] = num_move

      num_move = num_move + 1

      }

    • VoidSolution::removeMove(int row, int col)

      {tour_index[row][col] = -1

      num_moves = num_moves – 1

      }

    • VoidSolution::findIndex(int row, int col)

      {Return tour_index[row][col]

      }

    • Boolean Solution::isValid()

      {returnnum_moves == board_size * board__size

      }

    Concordia TAV 2002 Comp5421_2


    An alternative approach

    An Alternative Approach

    • Abstraction is a useful technique in problem solving. In the KT problem, we can abstract away from the board and its squares and, instead, think of the graph defined by knight's moves.

    • In the undirected graph, each vertex corresponds to a cell and each edge corresponds to a knight's move. This abstraction transforms the problem into the standard graph-theoretic problem of finding a Hamiltonian circuit. We can apply known results from graph theory to help us find solutions or identify situations in which there are no solutions.

    • For example, a graph has a Hamiltonian circuit only if all of its vertexes have even degree.

      Why?

    Concordia TAV 2002 Comp5421_2


    Comp5421 object oriented programming

    An Alternative Approach

    • A graph corresponding to 4x4 board: A table shows the graph of knight's moves: For 4x4 board, there is no KT because the vertices 2,3,5,8,9,12,14,15 have odd degree.

    Concordia TAV 2002 Comp5421_2


    Atoi function

    Atoi function

    • Atoi() function:

      #include <stdlib.h> // C header

      #include <cstdlib> // C++ header

      int atoi(const char *str);// Syntax

      Atoi function converts the string pointed to by str into an int value

      Example:

      #include <iostream>

      using namespace std;

      void main(int argc, char * argv[]){

      int size = 0;

      size = atoi(arg[1]);

      cout<< “size = “ << size << endl;

      }

    Concordia TAV 2002 Comp5421_2


    Evaluating a design

    Evaluating a Design

    • Design is not a single shot but an iterative process to add appropriate details. Fig.2.12 for final static structure of KT.

    • Design should be:

      The most important criterion is correction, that is, it must address and solve all issues, and the other:

      1. Simplicity: remove all unwanted details.

      2. Cohesive: everything in class is directed at a single purpose.

      Coupling: has minimal dependencies on the other classes

      3. Information hiding: high degree of abstraction, so that each class's implementation is invisible to other classes.

      4. Error handling must be thought about as part of the initial problem statement and should be an important design criterion in considering alternative designs. Moreover, the coding of a design should also emphasize error handling, through defensive coding techniques and appropriate interface definitions and in the assumptions made about valid and invalid values.

    Concordia TAV 2002 Comp5421_2


  • Login