Thread: Transition from Structs to Classes

This compiles and runs as intended as it is, but I need for those functions in the commented out "private:" to actually be private. I know I need to pass the data differently, but it has me stumped. If someone could please point(no pun intended) me in the right direction.

Code:

#include <iostream>
#include <fstream>
#include <string.h>

const int MAXname = 128;
const int MAXdetail= 4096;
const int MAXdate = 64;

using namespace std;

class Task
{

    public:
        static int loadData(Task x[], int &y);
        static int saveData(Task x[], int &y);

    //private:
        char taskName[MAXname];
        char taskDescription[MAXdetail];
        char taskDate[MAXdate];
};

class TaskList
{
    public:
        static int menuControl(Task x[], int &i, char z);
        static void showMenu();
        
    //private:
        static void inputAdd(Task x[], int &y);
        static void findTask(Task x[], int &y);
        static void printTask(Task x[], int &y);
};

int main()
{
    Task tmp[MAXname];
    int i = 0;
    char ch = ' ';
    Task::loadData(tmp, i);
    cout << "Welcome to Simple Task Organizer.\n" << endl;
    while(ch != 'q' && ch != 'Q')
    {
        TaskList::showMenu();
        cin.get(ch);
        cin.ignore(MAXname, '\n');
        TaskList::menuControl(tmp, i, ch);
    }
}

int Task::loadData(Task x[], int &y)
{
    ifstream in;
    in.open("tasks.txt");
    if(!in)
    {
        cout << "Could not find previously saved file, creating a new one!" << endl << endl;
        return 1;
    }
    while(in)
    {
        in.get(x[y].taskName, MAXname, ';');
        in.ignore(MAXname, ';');
        in.get(x[y].taskDescription, MAXdetail, ';');
        in.ignore(MAXdetail, ';');
        in.get(x[y].taskDate, MAXdate, '\n');
        in.ignore(MAXdate, '\n');
        y++;
    }
}

int Task::saveData(Task x[], int &y)
{
    int i = 0;
    
    ofstream in;
    in.open("tasks.txt");
    
    if(!in)
    {
        cout << "Could not save file. Where did it go?" << endl;
        return 1;
    }

    for(i = 0; i < (y - 1); i++)
        in << x[i].taskName << ';'
            << x[i].taskDescription << ';'
            << x[i].taskDate << endl;
            
    for(i = i; i < y; i++)
        in << x[i].taskName << ';'
            << x[i].taskDescription << ';'
            << x[i].taskDate;
    
}

void TaskList::showMenu()
{
    cout    << "********" << endl
            << "* Menu *" << endl
            << "********" << endl
            << "(a) add a task" << endl
            << "(p) show the task list" << endl
            << "(s) search for a previously entered task" << endl
            << "(q) exits the program" << endl
            << "Please enter an option: ";
}

int TaskList::menuControl(Task x[], int &y, char z)
{
    if (z == 'a' || z == 'A') 
    {
        TaskList::inputAdd(x, y);
        Task::saveData(x, y);
    }    
    
    if (z == 'p' || z == 'P')
        TaskList::printTask(x, y);

    if (z == 's' || z == 'S')
        TaskList::findTask(x, y);

    if (z == 'q' || z == 'Q')
    {
        cout << endl << "Thank you for using the Simple Task Organizer" << endl;
        return 0;
    }
}

void TaskList::inputAdd(Task x[], int &y)
{
    char a[MAXname];
    char b[MAXdetail];
    char c[MAXdate];
    char d;
    
    cout << "Please enter the name of the task: ";
    cin.get(a, MAXname, '\n');
    cin.get(d);
    
    cout << "Please enter the description of the task: ";
    cin.get(b, MAXdetail, '\n');
    cin.get(d);
    
    cout << "Please enter the due date of the task: ";
    cin.get(c, MAXdate, '\n');
    cin.get(d);
    
    strcpy(x[y].taskName, a);
    strcpy(x[y].taskDescription, b);
    strcpy(x[y].taskDate, c);
    
    y++;
}

void TaskList::findTask(Task x[], int &y)
{
    int a = 0;
    char b[MAXname];
    char c;
    
    cout << "Enter the name of the task to search for: ";
    cin.get (b, MAXname, '\n');
    cin.get (c);
    
    for(int i = 0; i < y; i++)
    {
        if (strcmp (x[i].taskName, b) == 0)
        {
            cout << endl << "********************************"
                    << endl << "* Task Planner ( Found Entry!) *" 
                    << endl << "********************************" 
                    << endl
                    << left << x[i].taskName << endl
                    << left << x[i].taskDescription << endl
                    << left << x[i].taskDate << endl << endl;
            a = 1;
        }
    }
    
    if (a == 0)
        cout    << endl << "************************************"
                << endl << "* Task Planner (No Results Found!) *" 
                << endl << "************************************\n*\n*\n*"
                << endl;
}

void TaskList::printTask(Task x[], int &y)
{
    cout << endl << "****************"
            << endl << "* Task Planner *" 
            << endl << "****************" 
            << endl;
    
    for(int i = 0; i < y; i++)
        cout << left << x[i].taskName << endl
                << left << x[i].taskDescription << endl
                << left << x[i].taskDate << endl << endl;
}

If you want to grant TaskList access to (what would be private) members of Task, you can do that. That is the purpose of the friend keyword.