代写关于C和C++的五个小练习，对比这两种语言之间的差异。
Objective
The objective of this lab is focused on a variety of subjects from C to C++.
Here is the summary of the some of the topics that are covered:
- Dynamic allocation of memory in C
- C structs with dynamic allocation of memory
- Introduction to C++ reference type
- Introduction to C++ classes
Note: some of the exercises in this lab are implemented in C and some in C++.
For the exercises that you need to compile and run them, please make sure to
use the correct compilation commands: - gcc for C programs
- g++ for C++ programs.
Exercise A: Allocation of Memory on the Heap
This is an in-lab exercise.
Read This First
Before doing this exercise, you should review lecture notes or a C textbook to
be sure you know exactly how C library function malloc works.
What to Do
Download the file lab7ExA.c and lab7ExA.h from D2L.Read these files carefully
and draw a memory diagram for point one, assuming that all the calls to the
library function malloc succeed.
What to Submit
Submit your diagram as part of your in-lab report.
Exercise B: C++ References
This is an In-lab exercise
Read This First
The AR notations that we use in ENCM 339 to show C++ references are different
from ordinary types such as: int, double, and pointer notations. When we
declare a reference we just provide an alias name for another memory space. In
other words, a reference in C++ doesn’t have its own memory space; therefore
we show them as a link (a line) between the reference-identifier and the
actual allocated memory spaces. There are two little circles on both ends of
these links. On one end there is a solid-black circle that represents the
reference, and on the other end there is an open circle that represents the
actual allocated memory space. Here are a few examples:
int a = 40;
intp = &a;
int& ra = a; // ra is referred to integer a
int& rp = p; // rp is referred to integer pointer p
int& rra = ra; // rra is also referred to a
—|—
Notice that all references ra, rp, and rra must be initialized with an
expression that represents an actual memory space or another reference.
What To Do
Download the file lab7ExB.cpp from D2L. Then, draw an AR diagram for point
one.
Note: You don’t need to compile and run this program but in case that you
decided to run it, you should use the g++ command which is the command to
compile C++ programs in our ICT 320 lab under the Cygwin. The executable file
created will be still a.exe, by default.
g++ -Wall lab7ExB.cpp
What To Submit
Submit your diagrams as part of your in-lab report.
Exercise C: Objects on the Computer Memory
This is also an In-lab exercise
The objective of this exercise is to help you in understanding how C++ objects
are shown on a memory diagram, and how a member function of a class uses the
‘this’pointer to access an object associated with a that particular call to
the function. For further details please refer to your lecture notes and
slides.
What to Do
Download files cplx.cpp, cplx.h, and lab7ExC.cpp from the D2L and draw AR
diagrams for: point one and point two.
For this exercise also you just need draw the diagrams. However, if you want
to compile and run it from command line in our ICT 320 lab, you should have
all of the given files in the same directory and from that directory you
should use the following command to compile and create an executable:
g++ -Wall cplx.cpp lab7ExC.cpp
Please notice that you shouldn’t have the header file name(s) in this command.
What To Submit
Submit your diagram as part of your in-lab report.
Exercise D: String Manipulation Using Dynamic Allocation in C
This is a post lab exercise.
The main objective of this exercise is to give you the opportunity to practice
dynamic allocation of memory in C, for the purpose of string operations such
as copying a string into another string, appending a string to the end of
another string, or truncating the size of a string.
Read This First
Creating a kind of wrapper data type that encapsulates several related data is
a common practice to build data structures such as vectors, string, linked
list, trees in object oriented programming languages such as C++. We will
discuss the proper way of applying these concepts during the lectures and
possibly future labs.
In this exercise a structure type, called Lab7Text is defined that is similar
to the structure given in Exercise A. This structure simply contains two
pieces of related data. First one is a pointer that is supposed to point to a
dynamically allocated array of characters, used as storage for a null-
terminated c-string, called text. Second one is an integer number that
represents the length of the stored string in the first data member (number of
characters up to but excluding the ‘\0’).
Here is the definition of this structure:
typedef struct Lab7Text{
char *text;
int length;
} Lab7Text;
—|—
What To Do First
Download the files Lab7Text.c and Lab7Text.h from D2L. In the file Lab7Text.c,
there are several functions as follows:
void create_empty_text (Lab7Text *txt);
—|—
Creates an object of Lab7Text that contains a string with one element holding
only a ‘\0’ and its length is zero.
void set_c_string(Lab7Text tx, const char s);
—|—
Copies a c-string from s into the dynamically allocate space in the object
that tx points to.
void text_append(Lab7Text tx, const Lab7Text tail);
—|—
Expands the length of dynamically allocated space for the c-string in tx to
allow appending the c-string from the object that tail points at, to the end
of the c-string inside the object that tx points at.
In this file in addition to a main function and the above-mentioned functions
there are also three test-function for testing function: text_copy,
text_append, and text_truncate.
Here is the first step, before your tasks starts: Compile and run the program
and find out how functions set_c_string and text_append work. The function
test_appending should produce an output that its first few lines and the last
line are as follows.
As this output shows for each call to the function text_append or function
set_c_string it tells you what is expected to be displayed, and then in the
following line the actual output which is a string and its length, is
displayed.
What To Do Second
Your next task in this exercise is to write the implementation of two missing
function text_copy and function text_truncate, according to the given
interface comments in the file Lab7Text.h. You are advised to write and test
one function at a time, and once the function works with no errors, start
working on the next function.
To complete this task, please take exactly the following steps:
- In the main function, change the conditional-compilation-directive for the call to test_copying from
#if 0to#if 1. - Read carefully the function interface comment for function text_copy in the header file Lab7Text.h and write the implementation of this function.
- Compile and run the program and make sure the test results matches with expected output indicated by the function test_copying. Once all tests passes successfully, go to the next step
- Change the conditional-compilation-directive for the call to test_truncating from
#if 0to#if 1. - Read carefully the function interface comment for function text_truncate and write the implementation of this function.
- Compile and run the program and make sure the test results matches with expected output indicated by the function test_truncating. Once all tests passes successfully, you are done with this exercise.
What To Submit
In your post-lab PDF file, include listings of the final versions of your
Lab7Text.c, and a listing of the output of the final version of your program.
Exercise E: Writing a Class Definition and Its Implementation
This is a post-lab exercise
Read This First - What is a Helper Functions?
One of the important elements of good software design is the concept of code-
reuse. The idea is that if any part of the code is repeatedly being used, we
should wrap it into a function, and then reuse it by calling the function as
many times as needed. In the past labs in this course and the previous
programming course, we have seen how we can develop global function to reuse
them as needed. A similar approach can be applied within a C++ class by
implementing helper-functions. These are the functions that are declared as
private member functions and are only available to the member functions of the
class – Not available to the global functions such as main or member functions
of the other classes.
If you pay close attention to the given instruction in the following “What to
Do” section, you will find that there are some class member functions that
need to implement almost a similar algorithm. They all need to change the
value of data members of the class in more or less similar fashion. Then, it
can be useful if you write one or more private helper-function, that can be
called by any of the other member functions of the class, as needed.
Read This Second - Defining Class Clock
In this exercise you are going to design and implement a C++ class called,
Clock that represents a 24-hour clock. This class should have three private
integer data members called: hour, minute, and second. The minimum value of
these data members is zero and their maximum values should be based on the
following rules:
- The values of minute, and second in the objects of class Clock cannot be less than 0 and more than 59.
- The value of hour in the objects of class Clock cannot be less than 0 and more than 23.
- As an example any of the following values of hour, minute, and second is acceptable for an object of class Clock (format is hours:minutes:seconds) : 00:00:59, 00:59:59, 23:59:59, 00:00:00. And, all of the following examples are unacceptable:
- 24:00:00 (hour cannot exceed 23)
- 00:90:00 (minute of second cannot exceed 59)
- 23:-1:05 (none of the data members of class Clock can be negative)
Class Clock should have three constructors: A default constructor, that sets
the values of the data-members hour, minute, and second to zeros.
A second constructor, that receives an integer argument in seconds, and
initializes the Clock data members with the number of hour, minute, and second
in this argument. For example if the argument value is 4205, the values of
data members hour, minute and second should be: 1, 10, and 5 respectively. If
the given argument value is negative the constructor should simply initialize
the data members, all to zeros:
The third constructor receives three integer arguments and initializes the
data members hour, minute, and second with the values of these arguments. If
any of the following conditions are true this constructor should simply
initialize the data members of the Clock object, all to zeros:
- If the given values for second or minute are greater than 59 or less than zero.
- If the given value for hour is greater than 23 or less than zero.
Class Clock should also provide a group of access member functions (getters,
and setters) that allow the users of the class to retrieve values of each data
member, or to modify the entire value of time. As a convention, lets have the
name of the getter functions started with the word get, and the setter
functions started with word set, both followed by an underscore, and then
followed by the name of data member. For example the getter for the data
member hour should be called get_hour, and he setter for the data member hour
should be called set_hour. Remember that getter functions must be declared as
a const member function to make them read-only funcitons.
All setter functions must check the argument of the function not to exceed the
minimum and maximum limits of the each data member. If the value of the
argument is below or above the limit the functions are supposed to do nothing.
What To Do
If you haven’t already read the above sections “Read This First” and “Read
This Second”, read them first. The recommended concept of helper function can
help you to reduce the size of repeated code in your program. Then, download
file lab7ExE.cpp from D2L. This file contains the code to be used for testing
your class Clock.
Now, take the following steps to write the definition and implementation of
your class Clock as instructed in the above “Read This Second” section.
- Create a header file called lab7Clock.h and write the definition of your class Clock in this file. Make sure to use the appropriate preprocessor directives (#ifndef, #define, and #endif), to prevent the compiler from duplication of the content of this header file during the compilation process.
- Create another file called lab7Clock.cpp and write the implementation of the member functions of class Clock in this file (remember to include “lab7Clock.h” ).
- Compile files lab7ExE.cpp (that contain the given main functions) and lab7Clock.cpp to create your executable file.
- If your program shows any compilation or runtime errors fix them until your program produces the expected output as mentioned in the given main function.
- Now you are done!
What To Submit
Submit your source code, lab7Clock.h, and lab7Clock.cpp, and the program’s
output as part of your post-lab report on the D2L, Dropbox.
