Basics of C/C++ Programming

2. Write a program that dynamically allocates a small array of ints. Fill the array and print its contents. Free the memory after you're done using it.

3. Write a program that reads the contents of a whole text file into a dynamically sized array of characters (and outputs the information into a new file).

Additional info:

Use "fseek", "ftell" and "rewind" to find out how large the buffer should be.

Make sure you have enough room for a null terminator. (You may have to assign it to the end of the array yourself)

Remember to free the allocated memory after calling malloc or calloc.

Make sure to check for error codes.

4. Create an implementation of a stack data structure (Stack (abstract data type)) that uses a dynamically allocated array for storage.

Required functions:
- init - Initializes stack's variables and allocates required dynamic memory with an initial(default) size,
- destroy - Frees all allocated memory and optionally resets other stored information for a stack,
- push - Adds an element to the top of the stack,
- peek - Gets the top element of the stack,
- pop - Gets and removes the top element of the stack;

Describe the stack struct and functions in a separate .h file,
Implement the functions in a corresponding .c file,
Test your stack with some operations. Remember to check for edge cases;

Hints:

How do you know which element to access?
How do you know if an array is full?
How should the functions behave when a stack is empty?
How should the functions behave when a stack is full?
What will happen if any of the functions are called many times or in unexpected order?

5. Write a program that reads an unknown number of integers (each on a separate line) from a file into the stack you created. After reading the whole file, print out all ints that were read (in reverse order).

Practice 3 (first half)

insertion sort, sorting structs

1. Implement insertion sort to sort an array of integers in ascending order.

2. Create a struct to hold integral key-value pairs. Modify the insertion sort algorithm to sort an array of these structs instead.

Assignment

Write a program that reads values from a file and outputs the result to stdout.

Input

Input file's name is "input.txt".

The file contains index-value pairs of integers on a single line. Integers in a pair are separated with a comma (,) and pairs are separated with a semicolon (;).

All indices between 0 and (count_of_pairs - 1) are guaranteed to be present.

The indices are guaranteed to be unique.

The indices are not guaranteed to appear in an ascending order.

Sample input: 1,4;0,2;2,8

Output

The program should output the differences between consecutive values as the index increases.

Output should be printed as a comma separated list of values on a single line to stdout.

For input:

0,1;2,4;1,2

Calculates:

0,1 to 1,2 -> 2 - 1 = 1
1,2 to 2,4 -> 4 - 2 = 2

And outputs:

1,2

Examples

->
0,2 -> 0
1,2;0,1 -> 1
1,4;0,2;2,8 -> 2,4
1,4;0,2;2,-2 -> 2,-6

C++

Practices

Practice 3 (second half)

C++ console i/o, std::string, std::vector, references, range based for, auto

1. Write a Hello, World! program in C++

2. Write a program that performs an addition operation based on user input. A sample input string: "2+2".

3. Write a program that asks the user for his name, stores it in an std::string and outputs the name back to the console window.

4. Write a program that asks the user for several strings and stores them in an std::vector. Upon receiving the last string, the program should output all strings in the order they were received.

5. Modify the last program by adding a function to modify a string by reference. Use that function on all input strings.

6. Modify the last program to output the strings using a range based for loop. Bind the values to an auto&.

Practice 4

file i/o, command line parameters, new/delete, classes, constructors/destructors, smart pointers

1. Read strings from a file into a std::vector<std::string>, then print them out to another file.

2. Modify the last program to read two file names from the command line and use these file names for files.

3. Create a class that logs its creation and destruction via std::cout. Use a custom defined constructor and destructor for that. Observe how actions are logged in different scenarios of instance creation and destruction, including smart pointers.

Practice 5

dynamic inheritance, (constructor) overloading, simple templates

1. Dynamic inheritance

Create a base class for several shape types, called Shape with:
- virtual default destructor
- an abstract function that returns the Shape's area
- an abstract function that returns the Shape's name
Create classes Rectangle and Shape that override the Shape and implement its methods
Use the classes in an std::vector<std::unique_ptr<Shape>> to find the names and areas of several mixed Shapes
Add an overloaded constructor to Rectangle that enables the user to customize the name of some Rectangles

2. Exercise

Create a hierarchy of Animals similarly to the Shapes (with animal names and sounds)
Provide an overloaded constructor for some Animal

3. Simple templates

Create a Queue of ints, that uses an std::deque as an underlying datatype
Provide methods to queue and dequeue values
Convert the Queue to a template class

4. Exercise

Create an Accumulator of ints
- stores an int as a member variable
- initial value of the accumulator is specified via the constructor
- has a member function that adds a value to the stored value (using the operator +=)
- has a member function that fetches the stored value
Template the Accumulator to store and add any type of values
(optional) Create a class Distance that can be used with the Accumulator
- wraps some value (like an int or a double) in a class
- overloads the operator+=

Practice 6

function pointers, std::function, lambdas, std::algorithm

1. Create a function that counts the number of odd numbers in an std::vector<int>

Store the function in a function pointer
Call the function via the function pointer
Store the function in an std::function
Call the function via the std::function variable

2. Re-implement the odd function counter as a lambda

Store the lambda in an std::function
Store the lambda in auto
Call the lambda

3. Exercise: Create a lambda that returns the position of the first negative number in a std::vector<int>

4. Lambda capture modes

Default by value
Default by reference
Named by value
- Create a lambda that calculates the factorial of an int that is captured by value
Named by reference
- Create a lambda that counts the number of negative numbers in an std::vector<int> that is captured by reference

5. Create a function zero_if:

Takes a reference to a container of ints as its first argument
Takes a comparison function as its second argument (std::function<bool(int)>)
Returns void
Sets each such value to 0 in the container for which the function returns true

6. std::algorithm (Without looping!)

Find the largest element in an std::vector<int>
Sort a vector of ints
- ascending
- descending, using a custom comparer
Count the number of strings that have a length of over 5 characters in std::vector<std::string>
Reverse all strings in a std::vector<std::string>

Practice 7

std::algorithm continued, nlohmann::json (consuming header only libraries)

json structure

1. Create a struct Person that has two fields: a name and an ID number

2. Using std::algorithm

Find a person by name from a std::vector<Person>
Find a person by the ID number from a vector<Person>

 vector<Person> people
 {
   Person { 11, "Jack"},
   Person { 43, "John Doe"},
   Person { 42, "Melissa"}
 };
 int idToFind = 43;
 auto location = find_if(begin(people), end(people), [idToFind](Person const& person)
 {
   return person.id == idToFind;
 });
 if (location != end(people))
 {
   // Person found!
   Person found = *location;
 }

Erase all negative values from a std::vector<int>
- Use std::remove_if to move all elements to be kept to the beginning of vector
- Use std::vector.erase() to erase the unnecessary elements from the end of the vector

 vector<int> ints{ -1, 2, -3, 4, -5, 6, -7, 8 };
 auto firstToRemove = remove_if(begin(ints), end(ints), [](int value) 
 {
   return value < 0;
 });
 ints.erase(firstToRemove, end(ints));

Remove all people whose name is longer than 4 characters and whose ID is odd from an std::vector<Person>

 // Remove people whose id is odd and name longer than 4 characters
 auto lambda = [](Person const& person)
 {
   return person.id % 2 == 1 && person.name.length() > 4;
 };

3. Consuming header only libraries (the simplest way)

Download the necessary header file
Move the header file to a well-known folder (project folder, some subfolder, etc)
#include the header file by specifying a relative path to the header

4. Using the nlohmann::json library

Open a .json file and read it into a nlohmann::json object in memory
Open a json file that contains some simple data (int, string, bool, array of ints)
- Read an integer from the json into an int
- Read a string from the json into an std::string
- Read a boolean from the json into a bool
- Read an array of ints from the json into an std::vector<int>
Open a json file that contains a single item with two integral values ("width" and "height")
- Read the object from the json into a struct Rectangle { int width; int height; }
Open a json file that contains an array of items with two values ("name" and "ID")
- Read the array from the json into an std::vector<Person>

Assignment

Pizza Shop:

Write a program that calculates the prices for pizzas and tells the pizza shop owner if they have enough ingredients to fill the order.

You are provided 3 files: recipes.json, ingredients.json and prices.json. These are all example files and your code must work with any kind of such file that matches the object syntax.

Each file contains a list of objects whose schema is defined below.

Prices contains the ids and prices for each price.

Ingredients contains the names, stock counts (total available quantity) and priceTypes for each ingredient - this is the amount of ingredients available for you during one program run. Ingredient priceType is matched with a Price from prices.json file (match them by their id number).

Recipes contains pizzas with ingredients - these are the same ingredients as in ingredients.json file (match them by their name).

Your program must read all .json files and provide console input where you can enter a pizza (pizza name) to be made. You can make any number of pizzas (at least until there are enough ingredients left).

Program usage:

1. Console asks for pizza name to be made

2. User enters pizza name

3.a. When the pizza can be made (is made):

Print to console the total price of the pizza.

Ingredients used must be taken off your stock.

3.b. When the pizza cannot be made:

Print out which ingredients are missing and how many.

4. --Return to step 1--

Datatypes (schema):

Pizza:

name - string

ingredients - list of strings

Ingredient:

name - string

quantity - integer

priceType - integer

Price:

id - integer

price - double

Basics of C/C++ Programming

Introduction

Lecturers

Video recordings of lectures and practices

Code from lectures

C

Practices

Practice 1

Practice 2

Practice 3 (first half)

Assignment

Input

Output

Examples

C++

Practices

Practice 3 (second half)

Practice 4

Practice 5

Practice 6

Practice 7

Assignment

Pizza Shop:

Program usage:

Datatypes (schema):

Pizza:

Ingredient:

Price:

Exploits

Lectures

Practices

Assignment

History

Basics_of_C/C++_Programming 2016

Navigation menu

Search