Learning c++ from c#

Question

0.00/5 (No votes)

See more:

What is the c++ quivalant of the following c# class file, separated into header file and cpp file:

class hello
{
     private string _fname, _lname;
     public hello(string fname, string lname)
     {
           setName(fname, lname);
     }
     public setName(string fname, string lname)
     {
          _fname = fname;
          _lname = lname;
     }
     public getName()
     { 
          return _fname + " " + _lname;
     }
}

Posted 6-Jul-10 6:09am

William Dyson

Updated 6-Jul-10 6:10am

v2

Add a Solution

2 solutions

Solution 2

First of all above c# code will never compile, because you are not specified the return type of setName and getName method.
modified version of C# code

C#

class hello
{
    private string _fname, _lname;
    public hello(string fname, string lname)
    {
        setName(fname, lname);
    }
    public void setName(string fname, string lname)
    {
        _fname = fname;
        _lname = lname;
    }
    public string getName()
    {
        return _fname + " " + _lname;
    }
}

C#

//hello.h - This class provides declaration of class Hello
#include <string>
class Hello
{
public:
    Hello(void);//default constructor
    Hello( const std::string& strFirstName,  const std::string& strLastName);
    void SetName( const std::string& strFirstName,  const std::string& strLastName);
    std::string GetName();
private:
    std::string m_strFirstName;
    std::string m_strLastName;
};

C#

//hello.cpp - This class provides implementation of class Hello
#include "Hello.h"
Hello::Hello(void)
{
}
Hello::Hello( const std::string& strFirstName,  const std::string& strLastName):
                m_strFirstName(strFirstName), m_strLastName( strLastName )
{

}
void Hello::SetName( const std::string& strFirstName,  const std::string& strLastName)
{
    m_strFirstName = strFirstName;
    m_strLastName = strLastName;
}
std::string Hello::GetName()
{
    return m_strFirstName + " " + m_strLastName;
}

Posted 6-Jul-10 20:06pm

SenAPI

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Aescleal · Accepted Answer · 2010-07-06T06:37:00

A good first stab would be:

// Class definition in name.h

#include <string>

class name
{
    public:
        name( const std::string &first, const std::string &last );
        std::string full_name() const;

    private:
        std::string first_name_, last_name_;
};

// Class implementation in name.cpp

name::name( const std::string &first, const std::string &last ) :
    first_name_( first ), last_name_( last )
{
}

std::string name::full_name() const
{
    return first_name_ + ' ' + last_name_;
}

Two things to consider here...

- why did I get rid of the setter method you had in your C# implementation? (another way to think about it is why should value classes be constant?)

- why are the functions non-virtual? (I think that's the equivalent of final in C# and Java, might be wrong though, don't use C#)

There are good reasons for both of them, which looking at your C# class makes me think they might not be idiomatic in C#.

Cheers,

Ash