Efficient way to fill a 2D Array?

[One Pea]

The function "arrayFill" fills a [10][10] 2D array with a sentence the user enters, and it works. I was wondering if their is a more efficient way of doing this?

  #include <iostream>

using namespace std;

class Functions
{
    private:
        char cipherArray[10][10];
        int input{};
        int counter{};
        string sentance;

    public:
        void arrayInitialize (char (&tempArray)[10][10])
        {
            for (int j=0;j<10;j++)
            {
                for (int i=0;i<10;i++)
                {
                    tempArray[j][i]='#';
                }
            }
        }

        void userInput (string &tempString)
        {
            cout << "Enter a sentance: ";
            getline (cin, tempString);
            cout << endl;
        }

        void arrayFill (char (&tempArray)[10][10])
        {
            for (int j=0;j<10;j++)
            {
                for (int i=0;i<10;i++)
                {
                    tempArray[j][i]=sentance[counter];
                    counter++;

                    if (counter==sentance.length())
                    {
                        break;
                    }
                }

                if (counter==sentance.length())
                {
                    break;
                }
            }

            for (int j=0;j<10;j++)
            {
                for (int i=0;i<10;i++)
                {
                   cout << tempArray[j][i] << "    ";
                }
                cout << endl;
            }
            cout << endl;
        }

        void menu ()
        {
            while (input!=3)
            {
                cout << "1. Transposition cipher" << endl;
                cout << "2. Code breaker" << endl << endl;
                cout << "Enter the number of the option you want to proceed with: ";
                cin >> input;
                cout << endl;
                cin.ignore();

                switch (input)
                {
                    case 1:
                        arrayInitialize(cipherArray);
                        userInput(sentance);
                        arrayFill(cipherArray);
                        break;

                }
            }
        }

};

int main()
{
    Functions program;
    program.menu();


    return 0;
}

[Enoizat]

I was wondering if their is a more efficient way of doing this?

Well, class properties are visible inside the methods of the same class, so you don’t need to pass them round.
Efficiency is important, but in OOP making a code easy to read and to maintain is pretty beneficial too, I think.
Here’s your code in ‘different clothing’:

#include <iostream>
#include <string>

constexpr unsigned ROWS { 10 };
constexpr unsigned COLS { 10 };

class Functions {
private:
    char cipher[ROWS * COLS];
    std::string sentence;

public:
    Functions();
    void menu ();
    void userInput();
    void arrayFill();
};

Functions::Functions()
{
    for (unsigned j = 0; j < ROWS; ++j) {
        for (unsigned i = 0; i < COLS; ++i) { cipher[j * COLS + i] = '#'; }
    }
}

void Functions::userInput()
{
    std::cout << "Enter a sentence: ";
    getline (std::cin, sentence);
}

void Functions::arrayFill()
{
    for (unsigned j = 0, counter {}; j < ROWS; ++j) {
        for (unsigned i = 0; i < COLS && counter < sentence.length(); ++i) {
            cipher[j * COLS + i] = sentence.at(counter++);
        }
    }

    for (unsigned j = 0; j < ROWS; ++j) {
        for (unsigned i = 0; i < COLS; ++i) {
           std::cout << cipher[j * COLS + i] << "    ";
        }
        std::cout << '\n';
    }
    std::cout << '\n';
}

void Functions::menu()
{
    int input {};
    while (input != 3) {
        std::cout << "1. Transposition cipher\n"
                     "2. Code breaker\n\n"
                     "Enter the number of the option you want to proceed with: ";
        std::cin >> input;
        std::cin.ignore();

        switch (input) {
        case 1:
            userInput();
            arrayFill();
            break;
        case 2: std::cout << "Not implemented yet!\n"; break;
        default: break;
        }
    }
}

int main()
{
    Functions program;
    program.menu();
    return 0;
}