I have everything working fine in my cod which i will post below the prompt but i don't know how to 1) Make the bool is_valid_dimensions function and 2) do the Interface, Implementation, or Makefile part. If someone could help me asap that'd be awesome:) Thanks! Here is the Prompt and the my code following:

#1 Arrays, Structs, Pointers, etc.

2. In this lab, you will create a dynamic two dimensional array of structs that contain the multiplication and division table of the rows and columns, starting at 1 instead of zero. This prevents us from causing a divide by zero error in the division table!

The program needs to read the number of rows and columns from the user as command line arguments. You do need to check if the user supplied a number before you convert the string to a number. Continue to prompt for correct values, if the number isnt a valid, non-zero integer. At the end of the program, prompt the user if he/she wants to see this information for a different size matrix. Make sure you do not have a memory leak!!!!

//Checked that rows and cols are valid, non-zero integers rows=atoi(argv[1]); cols=atoi(argv[2]);

For example, if you run your program with these command line arguments:

./prog 5 5

Your program should create a 5 by 5 matrix of structs and assign the multiplication table to the mult variable in the struct and the division of the indices to the div variable in the struct. The mult variable is an integer, and the div variable needs to be a float (or double).

struct mult_div_values { int mult;

float div; };

Your program needs to be well modularized with functions, including main, with 10 or less lines of code. This means you will have a function that checks if the rows and cols are valid, non-zero integers, bool is_valid_diminsions(char *m, char *n), and another function that creates the matrix of structs given the m x n dimensions, mult_div_values** create_table(int m, int n). In addition, you need to have functions that set the multiplication and division values, as well as delete your matrix from the heap:

void set_mult_values(mult_div_values **table, int m, int n) void set_div_values(mult_div_values **table, int m, int n) void delete_table(mult_div_values **table, int m)

Then, call functions to print the tables. Example: ./prog 5 t You did not input a valid column. Please enter an integer greater than 0 for a column: 5

Multiplication Table:

12345 2 4 6 8 10 3 6 9 12 15 4 8 12 16 20 5 10152025

Division Table: 1.00 0.50 0.33 .025 0.20 2.00 1.00 0.67 0.50 0.40 3.00 1.50 1.00 0.75 0.60 4.00 2.00 1.33 1.00 0.80 5.00 2.50 1.67 1.25 1.00

Would you like to see a different size matrix (0-no, 1-yes)? 0

#2 Interface, Implementation, and Makefile

3. Since we now have function prototypes and a struct that is a global user-defined

type, then we might want to begin making an interface file that holds all this information for us.

Create a mult_div.h interface file that will contain all the function and struct declaration information we need:

struct mult_div_values { int mult;

float div; };

bool is_valid_diminsions(char *, char *); mult_div_values** create_table(int, int); void set_mult_values(mult_div_values **, int, int); void set_div_values(mult_div_values **, int, int); void delete_table(mult_div_values **, int);

After creating this file, then you can include it into your implementation, .cpp file, and remove these prototypes and struct definition from your file.

#include ./mult_div.h Now, compile your program normally: g++ mult_div.cpp o mult_div

Lets take this a step further, and keep only your function definitions in this implementation file, i.e. mult_div.cpp, and put your main function in a separate implementation file called prog.cpp. Your prog.cpp file will have to include the mult_div.h file too. But, now how do we put these two files together? We have to compile them together, i.e. g++ mult_div.cpp prog.cpp o mult_div

What if we had 1,000 implementation (.cpp) files? We do not want to do this manually anymore, right? There is a built-in UNIX/Linux script that makes this easy! This is called a Makefile. Just vim Makefile to create it. Now, add the following to the file with the spacing being a tab!!!:

: -o

Example:

mult_div: g++ mult_div.cpp prog.cpp o mult_div

Now, save and exit the file. You can type make in the terminal to now run this file.

Lets learn a little more... We can add variables to the file and make compiling happen in different stages by stopping g++ after compiling and before running it through the linker. This creates object files, i.e. .o files, which you can link together.

CC = g++ exe_file = mult_div $(exe_file): mult_div.o prog.o

$(CC) mult_div.o prog.o o $(exe_file) mult_div.o: mult_div.cpp

$(CC) c mult_div.cpp prog.o: prog.cpp

$(CC) c prog.cpp

Try to make your program again. Notice all the stages. In addition, we usually add a target for cleaning up our directory.

clean: rm f *.out *.o $(exe_file)

Now, we can run the specific target by typing make , i.e. make clean.

Here's my code Below:

#include #include using namespace std;

struct mult_div_values { int mult; float div; };

bool is_valid_dimensions (char *rows, char *cols); struct mult_div_values** create_table (int m, int n); void set_mult_values (mult_div_values **table, int m, int n); void set_div_values (mult_div_values **table, int m, int n); void print_mult_table (mult_div_values **table, int m, int n); void print_div_table (mult_div_values **table, int m, int n); void delete_table (mult_div_values **table, int m, int n);

bool is_valid_dimensions(char *rows, char *cols) { if (rows = 0)

struct mult_div_values** create_table(int m, int n) { mult_div_values** table = new mult_div_values *[m]; for (int i = 0; i

void set_mult_values(mult_div_values **table, int m, int n) { for (int i = 1; i

void set_div_values(mult_div_values **table, int m, int n) { for (int i = 1; i

void print_mult_table (mult_div_values **table, int m, int n) { cout

void print_div_table (mult_div_values **table, int m, int n) { cout

void delete_table (mult_div_values **table, int m, int n) { for (int i = 0; i

int main(int arg,char* argv[]) { int rows = atoi(argv[1]); int cols = atoi(argv[2]); mult_div_values **table; table =create_table (rows, cols); set_mult_values(table, rows, cols); set_div_values(table, rows, cols); print_mult_table (table, rows, cols); print_div_table (table, rows, cols); delete_table(table, rows, cols); cout

return 0; }