how to add function in class but not in header file in C++?

Question

I am currently practicing writing classes and header files in C++. I have a question: let's say that in my header file I have a public function that a client can use, and I know how to implement it in the respective class. However, let's say that this function is divided into several steps that can be written as independent functions that I don't want the user to see (protect intellectual property). Normally, for each defined function in the header file, I would write in myClassName::myFunctionName(parameter 1..) in the.cpp file. Is there a way to define and use functions only in.cpp file? For example, I wrote a program to see if two words are anagrams (have the same letters).

My header file is:

#ifndef _Anagrams_h
#define _Anagrams_h
#include <string>
using namespace std;

class Anagrams{
    public:
        Anagrams(string &s);
        static bool areTwoWordsAnagrams(string s1, string s2) ; 
        string getWord()const; 
        void setWord(string &s);

    private:
        string word;

};
#endif

My class is:

#include "Anagrams.h"
#include <string>
using namespace std;

Anagrams::Anagrams(string &s){
    word = s;
}

bool Anagrams::areTwoWordsAnagrams(string word1, string word2){
    int sizeOfWord1 = word1.size();
    int sizeOfWord2 = word2.size();

    int array1[26];
    int array2[26];

    for (int i = 0; i < 26; i++){ //Initialize both arrays
        array1[i] = 0;
        array2[i] = 0;
    }


    decomposeWordIntoLetters(word1,array1,sizeOfWord1);
    decomposeWordIntoLetters(word2,array2,sizeOfWord2);

    return true;
}

string Anagrams::getWord() const{
    return word;
}

void Anagrams::setWord(string &s){
    word = s;
}

void decomposeWordIntoLetters(string word, int array[], int size){
    for (int i = 0; i < size; i++){
        char letter = word[i];
        array['z' - letter]++;
    }
}

Notice that the decomposeWordIntoLetters function is not defined in the header file. If I copy and paste the code twice in Anagrams::areTwoAnagrams(string word1, string word2), the program works. Otherwise, I get the following error:

Anagrams.cpp: In static member function ‘static bool Anagrams::areTwoWordsAnagrams(std::string, std::string)’:
Anagrams.cpp:22: error: ‘decomposeWordIntoLetters’ was not declared in this scope

Any help would be greatly appreciated. Thank you.

Answer 1

You can definitely have non-member functions in your cpp file. However, these functions may not be used before they declared or defined.

To declare a function, provide its prototype, like this:

void decomposeWordIntoLetters(string word, int array[], int size);

Put this line above the member function that calls decomposeWordIntoLetters . This should fix the compile problem that you are seeing.

When you define functions like that, you may want to hide them not only from the header, but also from other modules that link to your library. In order to do that, declare the function static :

static void decomposeWordIntoLetters(string word, int array[], int size);

Note that when you do that to a free-standing function, the meaning of static is completely different: the function does not become a class function as class-scoped static functions; instead, it becomes a function with the visibility limited to the translation unit (ie a single cpp file where it is defined).

Answer 2

There is no way to have class member functions which do not appear in the class declaration, and so if the declaration of a class is visible to the code which uses it, all of the member functions are visible.

There are ways to hide the implementations of entire classes, like the "pointer to implementation" pattern: you expose a class which is just an interface. It holds a pointer to some opaque object (whose full type declaration is not exposed to the user), and all of the public functions are just wrappers which call functions on that object.

class hidden_from_user;

class exposed_to_user {
private:
  hidden_from_user *impl;
public:
  // constructors, destructors, and so on.
  void frob(int howmuch);   
};

Inside the CPP file:

// full declaration of hidden_from_user is available here
#include "hidden_from_user.h"  // private header, not shipped as part of API
#include "exposed_to_user.h"

// ...

void exposed_to_user::frob(int howmuch)
{
   impl->frob(howmuch);
}

You have a lot of freedom to change the internals of hidden_from_user . Since the client code never defines instances of that type ( you are managing the memory), it is possible to change the layout of the object between releases of the code, even while the API remains forward and backward compatible at the binary level.

Answer 3

Declare function decomposeWordIntoLetters(word1,array1,sizeOfWord1); outside class in.h file

Just the prototype void decomposeWordIntoLetters(string, int[], int );