Operator overload in C++

Question

I’m learning operator overload. For this I am testing to overload the * operator so that it is interpreted as | string class object * variable type int = string class object concatenated with it so often the variable type int. Probably something like this already exists in the standard c++ but I’m doing it just to test. The problem is that the code is not working. The error messages are in the image below

Below the code:

Interface file. h

#pragma once
#include "stdafx.h"
#include <string>
using namespace std;

class palavra
{
private:
    string word;
public:
    string &operator*(const int &);
    void get_word();
    void print_word() const;
};

Implementation.cpp file

#include "stdafx.h"
#include "interface.h"
#include <iostream>

string palavra::&operator*(const int &numero)
{
    string word2=word;
    int cont;
    for (cont = 1; cont < numero; cont++)
        word += word2;

    return word;
}

void palavra::get_word()
{
    cout << "Digite a palavra a ser concatenada com ela mesma: ";
    getline(cin, word);
    cout << endl << endl;
}

void palavra::print_word() const
{
    cout << word;
}

Main file.cpp

// Sobrecargadeoperadores.cpp: Define o ponto de entrada para a aplicação de 
console.
//
//Sobrecarregar o operador para * para que a operação string * x faça a 
concatenação da string nela mesma x vezes
#include "stdafx.h"
#include <iostream>
#include "interface.h"
using namespace std;
int main()
{
    palavra word1;//a palavra a ser concatenada com ela mesma
    int numero;// a quantidade de vezes em que vai ocrrer a concatenação

    word1.get_word();

    cout << "\nDigite a quabtidade de vezes que vc quer concatenar a palavra 
    " << word1.print_word() << ": ";
    cin >> numero;

    cout << "A palavra " << word1.print_word() << "concatenada " << numero 
    << "vezes: " << word1*numero;

#if WIN32
    system("PAUSE");
#endif
    return 0;
}

implemenation.cpp(5): error C2589: '&': invalid token on the right side of '::'

\implemenation.cpp(5): error C2062: unexpected 'Unknown-type'

implemenation.cpp(6): error C2143: syntax error: ';' missing before '{' cpp(6): error C2447: '{': missing function header (old style formal list?)

overload.cpp(15): error C2679: '<<' binary : no found operator receiving a right-hand operand of type 'void' (or no acceptable conversion)

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

EDIT: Guys, I fixed the code. There were some syntax errors, another logic error that I missed. Now I think it’s good. Test image and corrected code just below

Interface file. h

#pragma once
#include "stdafx.h"
#include <string>
using namespace std;

class palavra
{
private:
    string word;
public:
    string operator*(const int &);
    void get_word();
    string &show_word() const;
};

File implmentation.cpp

#include "stdafx.h"
#include "interface.h"
#include <iostream>

string palavra::operator*(const int &numero)
{
    string word2 = word;
    int cont;

    for (cont = 1; cont < numero; cont++)
        word2 += word;

    return word2;
}

void palavra::get_word()
{
    cout << "Digite a palavra a ser concatenada com ela mesma: ";
    getline(cin, word);
}

string &palavra::show_word() const
{
    return word;
}

Main file.cpp

//Sobrecargadeoperadores.cpp: Define o ponto de entrada para a aplicação de 
console.
//Sobrecarregar o operador para * para que a operação string * x faça a 
concatenação da string nela mesma x vezes
#include "stdafx.h"
#include <iostream>
#include "interface.h"
using namespace std;

int main()
{
    palavra word1;//a palavra a ser concatenada com ela mesma
    int numero;// a quantidade de vezes em que vai ocrrer a concatenação

    word1.get_word();

    cout << "\nDigite a quabtidade de vezes que vc quer concatenar a palavra " 
<< word1.show_word() << " com ela mesma: ";
    cin >> numero;

    cout << "\nA palavra " << word1.show_word() << " concatenada " << numero 
<< " vezes com ela mesma: " << word1*numero << endl;

#if WIN32
    system("PAUSE");
#endif
    return 0;
}

Answer 1

Here is a functional example based on your code illustrating how to implement the multiplication operator operator* and the shift operators operator<< and operator>>:

#include <iostream>
#include <cstring>

/* ************************************************************************** */
/* *                               INTERFACE                                * */
/* ************************************************************************** */

class Palavra
{
    public:

        Palavra( void );
        virtual ~Palavra( void );

        Palavra operator*( int n ) const;

        friend std::ostream &operator<<( std::ostream &out, Palavra obj );
        friend std::istream &operator>>( std::istream &in, Palavra &obj );

    private:

        std::string m_palavra;

};

/* ************************************************************************** */
/* *                             IMPLEMENTACAO                             *  */
/* ************************************************************************** */

Palavra::Palavra( void )
{
}

Palavra::~Palavra( void )
{
}

Palavra Palavra::operator*( int n ) const
{
    Palavra p;

    for( int i = 0; i < n; i++ )
        p.m_palavra.append(m_palavra);

    return p;
}

std::ostream &operator<<( std::ostream &out, Palavra obj )
{
    out << obj.m_palavra;
    return out;
}


std::istream &operator>>( std::istream &in, Palavra &obj )
{
    in >> obj.m_palavra;
    return in;
}


/* ************************************************************************** */
/* *                                    main()                              * */
/* ************************************************************************** */

int main( void )
{
    Palavra p;
    int qtd = 0;

    std::cout << "Digite a palavra a ser concatenada com ela mesma: ";
    std::cin >> p;

    std::cout << "Digite a quantidade de vezes que vc quer concatenar a palavra [" << p << "] com ela mesma: ";
    std::cin >> qtd;

    std::cout << "A palavra [" << p << "] concatenada " << qtd << " vezes com ela mesma: " << p * qtd << std::endl;

    return 0;
}