{"id":1575,"date":"2024-10-28T18:08:27","date_gmt":"2024-10-28T18:08:27","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=1575"},"modified":"2025-01-20T20:08:59","modified_gmt":"2025-01-20T20:08:59","slug":"assignment-1b-simple-c-features","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/assignments\/assignment-1\/assignment-1b-simple-c-features\/","title":{"rendered":"Assignment 1b: Simple C++ Features"},"content":{"rendered":"\n

<\/span>Simple C++ Features<\/span><\/h2>\n\n\n\n

This part of the assignment is intended to illustrate some of the simpler C++ features, and to show some of the differences between C and C++.<\/p>\n\n\n\n

<\/span>Step 1<\/span><\/h3>\n\n\n\n

Write a\u00a0single<\/strong><\/em>\u00a0program to determine the\u00a0sizeof<\/strong><\/code>\u00a0each of the built-in types for C\/C++ (char, short, int, long, float, double, long double<\/strong><\/code>). <\/p>\n\n\n\n

For example:<\/p>\n\n\n\n

sizeof(long)\nsizeof(char)<\/code><\/strong><\/code><\/pre>\n\n\n\n
and also the sizes of literals<\/em> (not variables<\/em><\/strong>) of those types:<\/p>\n\n\n\n
\n
\n
Type<\/th>Example of literal of that type<\/strong><\/th><\/tr><\/thead>
char<\/code><\/td>'a'<\/code><\/td><\/tr>
short<\/code><\/td><There is no constant of type short><\/em><\/td><\/tr>
int<\/code><\/td>35<\/code><\/td><\/tr>
long<\/code><\/td>79L<\/code><\/td><\/tr>
float<\/code><\/td>1.3F<\/code><\/td><\/tr>
double<\/code><\/td>93.4<\/code><\/td><\/tr>
long double<\/code><\/td>37.9L<\/td><\/tr><\/tbody><\/table><\/figure>\n<\/div>\n\n\n\n
<\/div>\n<\/div>\n\n\n\n
for example:<\/p>\n\n\n\n
sizeof(1.3F)\nsizeof('a')<\/code><\/strong><\/code><\/pre>\n\n\n\n
In this latter case (of sizes of literals) it should not be necessary to use any variables for that part of the code.<\/p>\n\n\n\n
Note:<\/u><\/strong> I don’t want to see two different programs.  I want to see a single program<\/em>, identical in all respects for both C and C++.  The only difference is how you indicate to the compiler that it’s a C or a C++ program.<\/p>\n\n\n\n
Compile and run the program\u00a0using a C compiler, and then with a C++ compiler on the same platform<\/em><\/strong>.\u00a0<\/em>(If your C++ compiler is capable of acting as a plain C compiler, then use its plain C mode).<\/p>\n\n\n\n
Hint:<\/strong> Many different C++ compilers use a very simple device to determine whether a program is written in C or in C++:  it looks at the filetype<\/em>.  If the program has a .c<\/strong><\/code> filetype, then it assumes it must be a C program;  if the program has a .cpp<\/strong><\/code> filetype, then it assumes it must be C++.<\/p>\n\n\n\n
Unix systems<\/em> (most likely using the GNU C++ compiler), employ a similar convention.  C programs usually have a .c<\/strong><\/code> filetype;  C++ programs have a .C<\/strong><\/code> filetype (that is, an uppercase C<\/em> — remember, everything on Unix is case-sensitive).  However, in that environment, you may find that you may have to use different compilers for C and C++.<\/p>\n\n\n\n
In either situation, you will likely have to create a single .c<\/strong><\/code> file, and then, once you have it working satisfactorily, copy that file to one with a .cpp<\/strong><\/code> filetype (MS VC++) or a .C<\/strong><\/code> filetype (Unix), maintaining the same filename.  Then use the appropriate compiler to re-compile it in C++ and determine the differences.<\/p>\n\n\n\n
What differences do you observe? Explain them.<\/p>\n\n\n\n
<\/span>Step 2<\/span><\/h3>\n\n\n\n
Here is a legal ANSI C program. Your task is to convert it to C++.<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  friends.c<\/span><\/span>\n\/\/  Assignment 1b<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><stdio.h><\/span><\/span>\n#include<\/span> <\/span><stdlib.h><\/span><\/span>\n<\/span>\nenum<\/span> <\/span>sex<\/span> { <\/span>UNKNOWN<\/span>, <\/span>MALE<\/span>, <\/span>FEMALE<\/span> };<\/span><\/span>\n<\/span>\nstruct<\/span> <\/span>friend<\/span><\/span>\n{<\/span><\/span>\n  <\/span>char<\/span>     *name;<\/span><\/span>\n  <\/span>int<\/span>       age;<\/span><\/span>\n  <\/span>enum<\/span> <\/span>sex<\/span>  <\/span>sex<\/span>;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>print_friends<\/span>(<\/span>struct<\/span> <\/span>friend<\/span> <\/span>this<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>static<\/span> <\/span>char<\/span> *<\/span>class<\/span>[] = { <\/span>"?"<\/span>, <\/span>"M"<\/span>, <\/span>"F"<\/span> };<\/span><\/span>\n  <\/span>int<\/span> i;<\/span><\/span>\n<\/span>\n  <\/span>for<\/span> (i = <\/span>0<\/span>; <\/span>this<\/span>[i].<\/span>name<\/span> != <\/span>0<\/span>; i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>printf<\/span>(<\/span>" <\/span>%s<\/span>, Age: <\/span>%3d<\/span>, <\/span>%s<\/span>\\n<\/span>"<\/span>,<\/span><\/span>\n    <\/span>this<\/span>[i].<\/span>name<\/span>,<\/span><\/span>\n    <\/span>this<\/span>[i].<\/span>age<\/span>,<\/span><\/span>\n    <\/span>class<\/span>[<\/span>this<\/span>[i].<\/span>sex<\/span>]);<\/span><\/span>\n  }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>struct<\/span> <\/span>friend<\/span> <\/span>friends<\/span>[] =<\/span><\/span>\n  {<\/span><\/span>\n    { <\/span>"Mabel Smith"<\/span>, <\/span>23<\/span>, <\/span>2<\/span> },<\/span><\/span>\n    { <\/span>"Fred Jones"<\/span>, <\/span>42<\/span>, <\/span>1<\/span> },<\/span><\/span>\n    { <\/span>0<\/span>, <\/span>0<\/span>, <\/span>0<\/span> }<\/span><\/span>\n  };<\/span><\/span>\n  <\/span>struct<\/span> <\/span>friend<\/span> <\/span>new<\/span>[] =<\/span><\/span>\n  {<\/span><\/span>\n    { <\/span>"Clarence Brown"<\/span>, <\/span>25<\/span>, <\/span>1<\/span> },<\/span><\/span>\n    { <\/span>"Florence Tutwiler"<\/span>, <\/span>56<\/span>, <\/span>2<\/span> },<\/span><\/span>\n    { <\/span>0<\/span>, <\/span>0<\/span>, <\/span>0<\/span> }<\/span><\/span>\n  };<\/span><\/span>\n<\/span>\n  <\/span>printf<\/span>(<\/span>"I have the following friends:<\/span>\\n<\/span>"<\/span>);<\/span><\/span>\n  <\/span>print_friends<\/span>(friends);<\/span><\/span>\n  <\/span>printf<\/span>(<\/span>"I just met the following new people:<\/span>\\n<\/span>"<\/span>);<\/span><\/span>\n  <\/span>print_friends<\/span>(<\/span>new<\/span>);<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
    \n
  1. First, compile and run it under plain C, check that it works, and observe what it outputs.<\/li>\n\n\n\n
  2. Then copy the\u00a0friends.c<\/code><\/strong>\u00a0file to\u00a0friends.cpp<\/code><\/strong>\u00a0(or whatever is appropriate for your C++ compiler) and try to compile it using C++.<\/li>\n\n\n\n
  3. Determine the cause of each problem you encounter, fix it,\u00a0add a comment to the source code at that point, explaining what you did<\/em>, and try again.\u00a0
    To maintain your sanity, I strongly suggest that you make only one change at a time, rather than a wholesale set of changes!<\/em><\/li>\n\n\n\n
  4. Repeat the above step until done.<\/li>\n\n\n\n
  5. Document each change you make, in your source code, and explain why you had to make that change. Include in the description part of your submission a description of the actions you took (including any blind alleys you went down) to fix the problems you encountered.\u00a0<\/li>\n\n\n\n
  6. Eventually, you should be able to compile the program\u00a0with no errors, warnings,\u00a0or informationals<\/em><\/strong>, and be able to run it to produce the exact same results as the original program.<\/li>\n\n\n\n
  7. Document each change you make, in comments in your source code, and explain why you had to make that change. 
    Include in the description part of your submission a description of the actions you took (including any blind alleys you went down) to fix the problems you encountered.\u00a0<\/li>\n\n\n\n
  8. Eventually, you should be able to compile the program\u00a0with no errors, warnings,\u00a0or informationals<\/em><\/strong>, and be able to run it to produce the exact same results as the original program.<\/li>\n\n\n\n
  9. Now convert the C-style I\/O to C++ stream I\/O, to produce\u00a0exactly\u00a0<\/em>the same output.\u00a0Do not do this until you have completed all the other steps. I want to see a separate version with just the I\/O changes.<\/strong><\/em><\/li>\n<\/ol>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Step 3<\/span><\/h3>\n\n\n\n
    The following C++ function uses parameters which are of type\u00a0pointer to char<\/em><\/strong>, and uses pointer dereferencing to implement a circular shift of three characters:<\/p>\n\n\n\n
    \/* shift.cpp *\/\n#include \"shift.h\"\n\nvoid shift(char *a, char *b, char *c)\n{\n    char temp = *a;\n    *a = *b;\n    *b = *c;\n    *c = temp;\n}<\/code><\/pre>\n\n\n\n
    The header file\u00a0shift.h<\/code><\/strong> contains the function prototype for the\u00a0shift()<\/code><\/strong> function:<\/p>\n\n\n\n
    \/* shift.h *\/\n\nvoid shift(char *a, char *b, char *c);<\/code><\/pre>\n\n\n\n
    Convert the shift function into one that uses\u00a0reference parameters<\/em><\/strong>\u00a0instead of pointers, and rewrite the\u00a0shift.h\u00a0file to match this new form of the function.<\/p>\n\n\n\n
    To test that your function works correctly, write a\u00a0separately compiled<\/em><\/strong>\u00a0(that is, the main function will be in a separate .cpp file from the above function)<\/em>\u00a0C++ test program. It will print the before and after values of a shift.<\/p>\n\n\n\n
    <\/span>Step 4<\/span><\/h3>\n\n\n\n
    Here are some C++ structure declarations for\u00a0Person<\/strong>, for\u00a0Fruit<\/strong>, and for\u00a0Building<\/strong>:<\/p>\n\n\n\n
    \/* person.h *\/\n\nenum gender { UNKNOWN, MALE, FEMALE };\nstruct Person\n{\n    char    *name;\n    int      age;\n    gender   sex;\n};<\/code><\/pre>\n\n\n\n
    \/* fruit.h *\/\n\nenum fruit_type { BANANA, APPLE };\nenum hue { BROWN, GREEN, YELLOW };\nstruct Fruit\n{\n    fruit_type type;\n    hue        color;\n    double     weight;\n};<\/code><\/pre>\n\n\n\n
    \/* building.h *\/\n\nstruct Building\n{\n    char *name;\n    int   floors;\n    int   rooms;\n};<\/code><\/pre>\n\n\n\n
    Write three C++ (non-member) functions, called\u00a0Print()<\/code><\/strong>, each of which accepts a parameter of type\u00a0reference to<\/em>\u00a0Person<\/code><\/strong>, Fruit<\/code><\/strong>, or\u00a0Building<\/code><\/strong>, respectively. Each\u00a0Print()<\/code><\/strong> function will print out information about the contents of the structure passed to it.\u00a0<\/p>\n\n\n\n
    Ensure that all of the functions can coexist in the same compilation, and in the same program.<\/em><\/strong><\/p>\n\n\n\n
    The\u00a0Person<\/code><\/strong>,\u00a0Fruit<\/code><\/strong>, and\u00a0Building<\/code><\/strong>\u00a0types are totally independent of each other.\u00a0Therefore, each<\/em> Print()<\/code> <\/strong>function will be placed in its own separate source file, and\u00a0separately compiled<\/em>.\u00a0For each type, there will be a header file that contains the structure declaration, and all other publicly visible interfaces (including the function prototype for the<\/em> Print()<\/code><\/strong> function)<\/em>.<\/p>\n\n\n\n
    \n
    NOTE: Use the printf()<\/code><\/strong> function rather than C++ stream I\/O. You won’t have covered stream I\/O at this point, yet.<\/p>\n<\/blockquote>\n\n\n\n
    [Hint<\/strong>: Use\u00a0function name overloading<\/em> with\u00a0regular functions<\/em>,\u00a0not<\/em> member functions.]<\/p>\n\n\n\n
    The following\u00a0main()<\/code><\/strong>\u00a0function should work correctly, when linked against your code:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  Assignment 1b<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"person.h"<\/span><\/span>\n#include<\/span> <\/span>"fruit.h"<\/span><\/span>\n#include<\/span> <\/span>"building.h"<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  Person p = { <\/span>"Archie Bunker"<\/span>, <\/span>55<\/span>, MALE };<\/span><\/span>\n  Fruit f = { BANANA, YELLOW, <\/span>3.5<\/span> };<\/span><\/span>\n  Building b = { <\/span>"World Trade Center"<\/span>, <\/span>110<\/span>, <\/span>15000<\/span> };<\/span><\/span>\n  <\/span>Print<\/span>(p);<\/span><\/span>\n  <\/span>Print<\/span>(f);<\/span><\/span>\n  <\/span>Print<\/span>(b);<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    It should output the following:<\/p>\n\n\n\n
    Person:\n  Name:   Archie Bunker\n  Age:    55\n  Sex:    Male\nFruit:\n  Type:   Banana\n  Color:  Yellow\n  Weight: 3.5\nBuilding:\n  Name:   World Trade Center\n  Floors: 110\n  Rooms:  15000<\/code><\/pre>\n<\/div>\n<\/div>\n\n\n\n

    <\/p>\n","protected":false},"excerpt":{"rendered":"
    Simple C++ Features This part of the assignment is intended to illustrate some of the simpler C++ features, and to show some of the differences between C and C++. Step 1 Write a\u00a0single\u00a0program to determine the\u00a0sizeof\u00a0each of the built-in types for C\/C++ (char, short, int, long, float, double, long double). For example: and also the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":30,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-1575","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1575","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=1575"}],"version-history":[{"count":4,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1575\/revisions"}],"predecessor-version":[{"id":1592,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/1575\/revisions\/1592"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/30"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=1575"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}