Code works fine in visual studio, but when transferred over to Unix I receive errors?

Question

Not sure why Unix doesn't like my code for whatever reason, the code works perfectly on Visual Studio, I need to hand in a assignment by using a shell client, and when I try to do that I receive these errors. I am also sorry if this isn't the best question, I am just really confused about why this isn't working. Here are the errors:

w6_in_lab.cpp: In function âint main()â:
w6_in_lab.cpp:22:11: error: no match for âoperator=â in âA = B.sict::Account::operator+(C)â
w6_in_lab.cpp:22:11: note: candidates are:
Account.h:15:12: note: sict::Account& sict::Account::operator=(sict::Account&)
Account.h:15:12: note:   no known conversion for argument 1 from âsict::Accountâ to âsict::Account&â
Account.h:17:9: note: char* sict::Account::operator=(char*)
Account.h:17:9: note:   no known conversion for argument 1 from âsict::Accountâ to âchar*â
w6_in_lab.cpp:23:7: warning: deprecated conversion from string constant to âchar*â [-Wwrite-strings]
w6_in_lab.cpp:25:10: error: no match for âoperator=â in âA = B.sict::Account::operator+=((* & C))â
w6_in_lab.cpp:25:10: note: candidates are:
Account.h:15:12: note: sict::Account& sict::Account::operator=(sict::Account&)
Account.h:15:12: note:   no known conversion for argument 1 from âsict::Accountâ to âsict::Account&â
Account.h:17:9: note: char* sict::Account::operator=(char*)
Account.h:17:9: note:   no known conversion for argument 1 from âsict::Accountâ to âchar*â

I am not familiar with any of these errors as I am not very familiar with doing overloaded operators, and I never use Unix to do C++ assignments.

Here is the .h file:

#ifndef SICT_ACCOUNT_H__
#define SICT_ACCOUNT_H__
#include <iostream>
#include <cstring>
#include <iomanip>
namespace sict{
    class Account{
        char _name[41];
        double _balance;
    public:
        Account();
        Account(double balance);
        Account(const char name[], double balance);
        Account(const char name[]);
        Account& operator=(Account& ls);
        Account operator+=(Account& ls);
        char* operator=(char* ls);
        void display()const;
        double getBal();
        char* getName();

        friend double operator+=(double& ls, Account& rs);
        Account operator+(Account ls);

    };

    std::ostream& operator<<(std::ostream& ls, Account& rs);
};

#endif

The .cpp file:

#define _CRT_SECURE_NO_WARNINGS
#include <cstring>
#include <iomanip>
#include "Account.h"
using namespace std;
namespace sict{
    Account::Account(){
        _name[0] = 0;
        _balance = 0;
    }

    Account::Account(double balance){
        _name[0] = 0;
        _balance = balance;
    }

    Account::Account(const char name[], double balance){
        strncpy(_name, name, 40);
        _name[40] = 0;
        _balance = balance;
    }

    void Account::display()const{

        for(int x = 0; x < 40; x++){
            if(_name[x] == '\0')
                x = 40;
            else
                cout << _name[x];
        }

    cout << ": $" << setprecision(2) << fixed << _balance;

    }

    Account Account::operator+(Account ls) {

        return ls._balance + _balance;
    }

    double operator+=(double& ls, Account& rs){
        //cout << ls << endl;
        //cout << rs._balance+ ls << endl;
        return ls+=rs._balance;



        //return rs._balance+=ls;
    }

    Account Account::operator+=(Account& ls){

        return  _balance+=ls._balance;

    }

    Account::Account(const char name[]){
        strncpy(_name, name, 40);
    }

    char* Account::getName(){

        return _name;
    }

    double Account::getBal(){

        return _balance;
    }

    std::ostream& operator<<(std::ostream& ls, Account& rs){
        rs.display();
        return ls;
    }

    Account& Account::operator=(Account& ls){
        if( !strcmp(ls._name,"") &&ls._balance > 0)
        {
            strcpy(_name, "Saving");
        }

        _balance = ls._balance;
        //strcpy(_name, ls._name);

        return *this;

    }

    char* Account::operator=(char* ls){

        strcpy(_name, ls);

        return _name;

    }


}

and finally the main:

#include <iostream>
#include <string>
#include "Account.h"
using namespace sict;
using namespace std;

int main(){
  Account A;
  Account B("Saving", 10000.99);
  Account C("Checking", 100.99);
  double value = 0;
cout << A << endl << B << endl << C << endl << "--------" << endl;
  A = B + C;
  A = "Joint";
cout << A << endl << B << endl << C << endl << "--------" << endl;
A = B += C;
cout << A << endl << B << endl << C << endl << "--------" << endl;
value += A;
value += B;
value += C;
cout << "Total balance: " << value << endl;
  return 0;
}

Answer 1

A number of your problems are purely academic.

Your operator=() (and other functions) that take an Account& should take a const argument:

Account& operator=( const Account& ls );

Likewise, when you say A = "Joint" you are trying to assign a const string, but your operator only takes a mutable string. Fix its argument type:

Account& operator=(const char* ls);

Notice that the operator=() should still return a reference to *this.

Unfortunately, the best way to get used to these kinds of errors is to crank up VS's error reporting to the max and fix your code so that you get no errors.

Hope this helps.