c/c++编程代做、代写program程序

日期：2023-10-27 10:45

Department of Electrical Engineering and Electronics

Assignment Overview

Instantiation and manipulation of geometrical objects is significant in robotics. It is also

advantageous to be familiar with object-oriented programming features in C++. In this

assignment, you will design C++ classes capable of initialising polygons in a particular way,

and performing translations and rotations on them. This tests your ability to declare and define

classes and instantiate objects, using constructors, inheritance and polymorphism.

ELEC230 Robotic Systems

Assignment 1 – Object-Oriented Programming: Classes & Objects in C++

Module / Coursework ELEC230 / Assignment 1 – Classes & Objects in C++

Component weight 15%

Semester / HE Level 1 / 5

Lab location EEE PC Labs A402 & A406

Work Individual

Timetabled time C++ practice & advice are available in Weeks 4 – 7, totalling up to

15 hours although some time will be given to other topics. Lab

time includes time practising the C++ and OOP (Object-Oriented

Programming) exercises provided. You may ask questions about

the Assignment & relevant skills, and work on the Assignment

individually. You must write your own code & report, and

collusion, copying or plagiarism will be penalised.

Suggested private study ~10 hours – in addition to the timetabled time learning and

practising C++ and OOP.

Assessment method Individual, formal word-processed reports and .cpp files, as

described in the Marking Criteria.

Submission format Online via CANVAS using the template.

Please adhere to the template word and page limits.

Submission deadline 23:59 on Friday 10

th November 2023

Late submission Standard University penalties apply

Resit opportunity N/A

Marking policy Marked and moderated independently

Anonymous marking Yes

Feedback Via comments on CANVAS submission on-line

Learning outcomes (BH2) Understanding the features of an Object-Oriented

Programming language, and the ability to code in C++.

2

How much time did it

take YOU?

Let us know anonymously via https://bit.ly/EEECARES

Aspect

Marks

available

Indicative characteristics

Adequate / pass (40%) Very good / Excellent

Presentation

and

structure

10%

? Submission includes a Report, plus a

standalone .cpp file for each Part

attempted (one .cpp file each for Part A

and Part B). The latter are zipped while

the former is not.

? Report contains cover page

information (with Academic Integrity

declaration & Abstract), table of

contents, sections with appropriate

headings.

? Comprehensible language;

punctuation, grammar and

spelling are accurate.

? Equations, figures & tables are legible,

numbered and presented correctly.

? Excellent use of technical,

mathematic and academic

terminology and conventions.

? Word processed with consistent

formatting.

? Pages numbered, figures and

tables are captioned well.

? All sections clearly signposted.

? Excellent cross-referencing (of

figures, tables, equations) and

citations.

Introduction,

Method and

Design

40%

? Problem background is introduced

clearly

? Original code and comments

? Code is clearly laid out, easy to follow

and well- commented

? Design of each code segment follows a

logical sequence

? Design is adequately explained

? Excellent understanding of the

problem background is

displayed

? Code for each task is clean,

Don’t Repeat Yourself (in

programming), efficient and

elegant

? [Code is user-friendly if / when

relevant]

? Design is very well explained

Results 30% ? Focused screenshots of program

output are presented for each task

? These include the printed output at

the terminal, and output in Desmos

and GeoGebra.

? Full-screen versions of each focused

screenshot are dumped in the

Appendix (in order of appearance in

the report). These must include the

full desktop including the taskbar

with date and time, and for the

terminal screenshots, they must also

include the IDE windows (e.g. editor

window showing program code).

? Screenshots correspond with code and

demonstrate at least partially correct

operation

? Screenshots, along with valid

code, clearly demonstrate

successful, correct output for

every task, in perfect

agreement with the

instructions and in the most

efficient way allowed by

them

? Printing to the terminal is

neat and comprehensible

(e.g. appropriate spaces, line

breaks, spelling, etc.) and

follows the exact form

instructed

? Screenshots are presented in a

coherent way that

corresponds well with the

logical flow of the report

3

Discussion 20% ? Written discussion within each task

explaining each code segment. This

discussion is clearly original and shows

understanding of the relevant syntax

and semantics.

? This written discussion is in addition to

the code comments. It is accompanied

by snapshots of snippets of the code, to

illustrate the explanations.

? Discussion shows excellent

understanding.

? Coding decisions are justified.

e.g., rejected alternatives

explained.

? Some discussion of what might

be done to further enhance /

improve the program

ELEC 230 C++ & OOP Assignment 1 (2023-2024)

ProgramA (70%):

1. Write a class called polygon which can initialise regular1 Two-Dimensional (2D) polygons, and

translate them in the +/-x and +/-y directions (or both x and y). It should also be able to rotate

them by any number of degrees about any point. Come up with your own names for all class

members except N and r. The following members must be included in your class, exactly as

instructed, and must serve a meaningful purpose in your program:

? Private members:

o Member of type std::string, to store a ‘user’-defined polygon name (e.g. “t_1”)

? Note: the ‘user’-defined polygon name must always take the form l_i where

l is a letter, i an integer; this also applies in ProgramB.

o Member (r) of type double, to store the radius.

o Member (N) of type integer, to store the number of vertices.

o Member of type std::vector, to store the x-coordinates of the polygon vertices.

o Member of type std::vector, to store the y-coordinates of the polygon vertices.

o Member function which prints any object’s name, number of vertices and coordinates

(as a coordinate pair for each vertex) on screen using the standard output stream. The

printed output must take the following exact form (although obviously the ‘user’

defined polygon name, the coordinates and the number of coordinate pairs will vary).

All numerical printed output should be rounded to 5 decimal places:

t_1=polygon((1.73205,-1),(0,2),(-1.73205,-1))

? Public members:

o Constructor function which, firstly, accepts and stores the name, r and N. Secondly, it

then uses this data to initialise and store the coordinates of the polygon vertices. When

initialised, each polygon must be centred on the origin (0,0), and its base must be

horizontal (parallel with the x axis). o Member function to translate any object, and

efficiently print the object name and coordinates before and after translation, and the

translation vector applied, in the following exact form:

Before translation: t_1=polygon((1.73205,-

1),(0,2),(-1.73205,-1)) After translation by

[-4,0]:

t_1=polygon((-2.26795,-1),(-4,2),(-5.73205,-1))

o Member function to rotate an object of this class about any point, and efficiently print

the object name and coordinates before and after rotation; also, how many degrees of

rotation were applied and from what point the rotation was around. (Positive rotation

is anticlockwise.) In the following exact form:

Before rotation:

t_1=polygon((1.73205,-1),(0,2),(-1.73205,-1))

After rotation 90 degrees anticlockwise about (1,2):

t_1=polygon((4,2.73205),(1,1),(4,-0.73205))

1

‘Regular’ means that all the polygon’s internal angles are the same, and all edges are of identical length.

4

o The word ‘efficiently’ underlined twice above implies that there are opportunities here

to avoid repeating code (DRY). Can you work out how?

2. Write a program incorporating the above class in the global scope. In your ‘main’ function,

instantiate a triangle, a square and an ??-gon (you choose ?? > 4) using your constructor function

created above. For each polygon, following instantiation, call sequentially first the translation,

then the rotation function. Rotation must be by 90o about (a,b) and translation by (a,-b), where

a and b are the final two non-zero digits in your student ID. For each stage, (instantiation,

rotation and translation) copy and paste the relevant terminal output into

https://www.desmos.com/calculator to generate an image of a polygon, and include screenshots

of both the terminal output and the Desmos polygon in your report, as evidence of your working

program (see also Marking Criteria).

5

ProgramB (30%):

Write a second program2 by following the steps below:

1) Copy and alter your class “polygon” to create a new class3

, “polygon3d”, that can initialise,

store and print any shape – regular or irregular – in Three-Dimensional (3D) space. Get rid of the

member variable for radius, which is no longer meaningful, and alter the constructor function so that it

now directly accepts and store the coordinates of the vertices. Delete N too. Don’t make other changes

yet.

2) Rotation and translation need not be defined in polygon3d. Therefore, turn the functions for

translation and rotation into pure virtual members, making polygon3d into an abstract base class.

Convert the private members of polygon3d into ‘protected’ members to allow a layer of inheritance.

3) Create three new classes publicly inherited from polygon3d, called polygon_xy, polygon_xz

and polygon_yz. Each class must only be able to perform rotations and translations in its own active

set of planes (defined by xy, xz or yz). You should achieve this by overriding polygon3d’s translation /

rotation functions in each inherited class.

? E.g. objects of the polygon_xy class can be translated by (1,2,0) but not by (1,2,5), since this would involve

an alteration of the z-coordinates i.e. ‘movement’ in a plane other than an xy plane.

? E.g. objects of the polygon_xy class can only be rotated in an xy plane – again, z-coordinates can’t be

altered by rotations, since this would entail ‘movement’ in a plane other than an xy plane.

? Similar rules apply for polygon_xz and polygon_yz in accordance with the planes given in their names.

See the ‘Assignment 1 Support’ folder (which will be updated periodically) for help with constructor

inheritance.

Important: the format of your efficient printed output to terminal should now be changed slightly so

that the line containing name and coordinates looks like the following exact form (for example):

t_1=Polygon({(0,0,0),(2,1,3),(1,3,4)})

In a similar way to ProgramA, create a program, instantiate one object of each class, and apply a

translation and a rotation sequentially to each object. This time, choose your own (non-zero) rotation

and translation coordinates. Test and produce evidence for your report in

https://www.geogebra.org/calculator using the ‘3D Calculator’ option (in a similar way as before with

Desmos), and with terminal output screenshots.

Now choose either Task 4 or Task 5 (Not both):

4) For one of the above inherited classes, add a public member function which overloads the +

operator to add one triangle’s coordinates to another’s in a single operation. You should be able to code

“object3 = object1 + object2” with the result that the coordinates of object3’s vertices in each dimension

become a sum of those of object1 and object2. E.g.:

0

o object1 vertex coordinates: (1,2,5), (2,8,5), (4,1,5)

o object2 vertex coordinates: (2,4,6), (3,5,8), (2,1,8)

o ? object3 vertex coordinates become: (3,6,11), (5,13,13), (6,2,13)

2 Save your original program (ProgramA) as a .cpp file. Then, simply copy the code for class “polygon” into a new

.cpp file, rename the class “polygon3d” and modify it according to the instructions.

6

Your function should also be able to efficiently achieve printing of information about the operation,

and object details before/after it, just as with the rotation/translation functions above & in ProgramA.

In your ‘main’, instantiate some triangular objects & call this function to demonstrate its operation.

Provide appropriate evidence of this with screenshots of GeoGebra and terminal output.

5) Alternatively, in your ‘main’ function, instantiate 3 objects, each of a different inherited class

from (3). Then, by using an array of base class pointers, pointing to objects of the derived classes in

question (3), write code in your ‘main’ function to batch-translate the objects of the different derived

classes, with a single for-loop. Translations should be non-zero in the appropriate plane for each object.

(Again, choose your own translation vectors). You will utilise pre-existing functions – so, just as above

and in ProgramA, details of the individual operations and starting/finishing object details should be

efficiently printed as part of the process. Provide appropriate evidence of the batch translation with

screenshots of Desmos or Geogebra and terminal output, as before.

Notes for BOTH Parts A and B:

? All objects should be stored in the code (e.g. creating a new object of class polygon should

not have to involve deleting a previous object of this class.)

? You should find that the transformations performed by your member functions actually

alter the stored object’s attributes. So, for example, if a translation is followed by a rotation

on the same object, the coordinates passed into the rotation are the new coordinates

following the translation. (This is a requirement of the Assignment.)

? Don’t try to interface with the ‘user’ – there is no need to issue messages to the user

inviting them to enter input, etc. When instantiating or manipulating objects, just hardcode

these actions into your main function, on behalf of the ‘user’. Similarly, don’t try to create

a menu-driven program!

Important Further Hints and Notes:

1. In this particular assignment, it isn’t the destination – it’s the journey. This means that in this

assignment, the learning objectives in respect of C++ and OOP are met by following the design

instructions closely, paying particular attention to object-oriented-programming and code

efficiency where possible/relevant, and not worrying too much about (perceived) usefulness of

the resulting programs. Don’t try and shortcut the assignment instructions!

2. Refer to the ‘Assignment 1 Support’ folder – and keep referring back, as it will be periodically

updated (it may not contain much when you first look there.)

3. When it comes to writing your report, use the Submission Template which will be added to the

above folder in due course.

4. I would like to emphasise something already mentioned: DO NOT try and invite a ‘user’ to

instantiate or manipulate objects at runtime – just instantiate/manipulate ‘directly’ (on behalf of

the ‘user’, if you will) within the code of your ‘main’ function. So there will not be any call and

response at the terminal – when your programs are run, they will simply generate a bunch of

output according to what instructions you have given in the main function.

5. To initialise each polygon in Part A, you will need to first set its coordinates using N and r, then

rotate it about the origin by some amount so that the base lies ‘horizontal’.

6. Rotational matrix equation for 2D rotation of a single coordinate point, where ??, ?? are the

starting coordinates, ??′, ??′ are the coordinates after rotation, and ?? is the angle of rotation about

the origin:

7

x' = x * cos(θ) - y * sin(θ)

y' = x * sin(θ) + y * cos(θ)

7. For the rotation function, you may find that you want to create a copy of your object. Note,

firstly, that the ‘=’ operator will automatically invoke the default copy constructor

(Without you needing to write a copy constructor). But what to make it equal to? That’s

where the ‘this’ keyword could come in handy. ‘this’ is a keyword which refers to the

current object. Since ‘this’ is actually a pointer, dereference it (*this) and make your

dummy/copy object equal to it.

8. If in doubt, assume within reason that the same rules about functionality and output apply for

ProgramB as ProgramA unless instructed differently. If still unsure, ask!

9. Read the Marking Criteria on Page 2 of this Assignment brief and take a look at the Assignment

1 Discussion Board on Canvas – even if you don’t have any questions, the answers to questions

there might reveal misconceptions you didn’t know you had.

Note: In the Robot Operating System (ROS), 3D rotations are achieved with quaternions. Although this

Assignment does not ask you to perform full 3D rotations or use quaternions, you can read more about

them here.

What to submit

1. Commented standalone code for each program, should be formatted and added to the report.

2. A Report as a pdf:

? Your Report should strictly follow the template provided sticking to page and word limits.

o Screenshots for each task, showing (a) the program output at the terminal and (b) the

corresponding polygons generated in Desmos or GeoGebra. (These should, of course, be

presented as figures with figure numbers and captions and annotation if required. Feel

free to combine the polygons on 1 graph)

o A discussion of each program’s design and results, showing your understanding of your

own code and of C++ features used. You can enhance this with snapshots or snippets of

your code,

? Your Report should also an Appendix with full-screen screenshots as instructed in the

Marking Criteria, p.2, in the same order of appearance as in the main body of the report.

? Follow also all the other instructions in the Marking Criteria, p.2.

Warning

When marking your reports, we will be looking very closely for any signs of collusion, as this is unacceptable.

We want to assess your own ability, not that of your friend or colleague. If we find any evidence of collusion or

copying then the formal University rules will be followed which may result in your suspension. Similarly, your

code, comments and discussion must be your own and not taken from any other source (e.g. online.) If we find

evidence that part(s) of your work is/are copied or closely paraphrased from any source then the formal University

rules will be followed on plagiarism and collusion, which may result in your suspension or termination of studies.

Submission information / deadline

Submit an Electronic copy to CANVAS by: 23:59 on Friday 10

th November 2023.