C++ 如何在单独文件中定义的成员函数中使用成员变量

userInput.hpp

#include <string>

class UserInput{
public:

    std::string rawInput;
    std::string parseUserInput;

}; 

#包括
类用户输入{
公众：
std：：字符串输入；
std：：字符串parseUserInput；
}; 

userInput.cpp

#include <iostream>

#include "userInput.hpp"
#include "stringManipulation.hpp"

using namespace std;

string branchCommand;

string parseUserInput(){

    removeWhiteSpaces(rawInput);

    return branchCommand;
}

#包括
#包括“userInput.hpp”
#包括“stringManipulation.hpp”
使用名称空间std；
字符串分支命令；
字符串parseUserInput（）{
删除空白（rawInput）；
返回分支命令；
}

我在userInput.hpp中创建了一个类，其成员函数为

parseUserInput

，我的意思是在userInput.cpp中定义该函数。但是，当我尝试在定义中使用rawInput时，我必须将其声明为

static

---

是否可以在函数定义中使用另一个文件中的

rawInput

字符串而不使

rawInput

变量为静态？

首先，您已将

parseUserInput

声明为hpp中的字符串字段，而不是函数。使用parethese将其声明为成员函数

std::string parseUserInput();

其次，在userInput.cpp中，您定义的是名为

parseUserInput（）

的全局函数，而不是成员函数。要在

UserInput

类上定义成员函数，请使用范围解析运算符

：

std::string UserInput::parseUserInput() {
    ...
}

---

最后，您应该避免在代码中使用语法。首先，您在hpp中将

parseUserInput

声明为字符串字段，而不是函数。使用parethese将其声明为成员函数

std::string parseUserInput();

其次，在userInput.cpp中，您定义的是名为

parseUserInput（）

的全局函数，而不是成员函数。要在

UserInput

类上定义成员函数，请使用范围解析运算符

：

std::string UserInput::parseUserInput() {
    ...
}

---

最后，您应该避免在代码中出现错误。

您好，您是否考虑过创建get函数

std::string returnRawInput() {return rawInput;}

---

然后您可以调用此函数来获取输入…

您好，您是否考虑过创建一个get函数

std::string returnRawInput() {return rawInput;}

---

然后可以调用此函数以获取输入…

您当前的类如下所示：

userInput.hpp

// Missing Header Guards Or #Pragma Once
#include <string>

class UserInput{
public:    
    std::string rawInput;        // Member Variable of UserInput      
    std::string parseUserInput;  // Member Variable of UserInput   
};

#ifndef USER_INPUT_HPP
#define USER_INPUT_HPP

#include <string>

class UserInput {
public:
    std::string rawInput; // Member Variable
    std::string parseUserInput(); // Now a Member Function that Returns a std::string
};

#endif // USER_INPUT_HPP

#include <iostream>
#include "userInput.hpp"
#include "stringManipulation.hpp"

std::string branchCommand; // Still a bad idea if not const or static

std::string UserInput::parseUserInput( /* should this take a string from the user? */ ) {
    removeWhiteSpaces( rawInput );

    return branchCommand; // ? ... Still not sure what you are returning.
}

//缺少标题保护或#Pragma一次
#包括
类用户输入{
公众：
std:：string rawInput；//UserInput的成员变量
std:：string parseUserInput；//UserInput的成员变量
};

userInput.cpp

#include <iostream>                // Okay    
#include "userInput.hpp"           // Okay
#include "stringManipulation.hpp"  // Okay

using namespace std;   // Bad Practice

string branchCommand;  // non const local Global Variable - can be bad practice 

// Looks like a global function that is not a part of your class
string parseUserInput(){

    removeWhiteSpaces(rawInput);

    return branchCommand;   // returning global variable that isn't used?
}

#包括//好的
#包括“userInput.hpp”//OK
#包括“stringManipulation.hpp”//OK
使用命名空间std；//坏习惯
字符串branchCommand；//非常量局部全局变量-可能是不好的做法
//看起来像不是类的一部分的全局函数
字符串parseUserInput（）{
删除空白（rawInput）；
return branchCommand；//返回未使用的全局变量？
}

你是说

userInput.hpp

// Missing Header Guards Or #Pragma Once
#include <string>

class UserInput{
public:    
    std::string rawInput;        // Member Variable of UserInput      
    std::string parseUserInput;  // Member Variable of UserInput   
};

#ifndef USER_INPUT_HPP
#define USER_INPUT_HPP

#include <string>

class UserInput {
public:
    std::string rawInput; // Member Variable
    std::string parseUserInput(); // Now a Member Function that Returns a std::string
};

#endif // USER_INPUT_HPP

#include <iostream>
#include "userInput.hpp"
#include "stringManipulation.hpp"

std::string branchCommand; // Still a bad idea if not const or static

std::string UserInput::parseUserInput( /* should this take a string from the user? */ ) {
    removeWhiteSpaces( rawInput );

    return branchCommand; // ? ... Still not sure what you are returning.
}

\ifndef用户输入\u水电站
#定义用户输入HPP
#包括
类用户输入{
公众：
std:：string rawInput；//成员变量
std:：string parseUserInput（）；//现在是一个返回std:：string的成员函数
};
#endif//USER\u INPUT\u HPP

userInput.cpp

// Missing Header Guards Or #Pragma Once
#include <string>

class UserInput{
public:    
    std::string rawInput;        // Member Variable of UserInput      
    std::string parseUserInput;  // Member Variable of UserInput   
};

#ifndef USER_INPUT_HPP
#define USER_INPUT_HPP

#include <string>

class UserInput {
public:
    std::string rawInput; // Member Variable
    std::string parseUserInput(); // Now a Member Function that Returns a std::string
};

#endif // USER_INPUT_HPP

#include <iostream>
#include "userInput.hpp"
#include "stringManipulation.hpp"

std::string branchCommand; // Still a bad idea if not const or static

std::string UserInput::parseUserInput( /* should this take a string from the user? */ ) {
    removeWhiteSpaces( rawInput );

    return branchCommand; // ? ... Still not sure what you are returning.
}

#包括
#包括“userInput.hpp”
#包括“stringManipulation.hpp”
std:：string branchCommand；//如果不是常量或静态，这仍然是个坏主意
std:：string UserInput:：parseUserInput（/*应该从用户那里获取字符串吗？*/）{
删除空白（rawInput）；
return branchCommand；//？…仍然不确定返回的是什么。
}

您当前的类如下所示：

userInput.hpp

// Missing Header Guards Or #Pragma Once
#include <string>

class UserInput{
public:    
    std::string rawInput;        // Member Variable of UserInput      
    std::string parseUserInput;  // Member Variable of UserInput   
};

#ifndef USER_INPUT_HPP
#define USER_INPUT_HPP

#include <string>

class UserInput {
public:
    std::string rawInput; // Member Variable
    std::string parseUserInput(); // Now a Member Function that Returns a std::string
};

#endif // USER_INPUT_HPP

#include <iostream>
#include "userInput.hpp"
#include "stringManipulation.hpp"

std::string branchCommand; // Still a bad idea if not const or static

std::string UserInput::parseUserInput( /* should this take a string from the user? */ ) {
    removeWhiteSpaces( rawInput );

    return branchCommand; // ? ... Still not sure what you are returning.
}

//缺少标题保护或#Pragma一次
#包括
类用户输入{
公众：
std:：string rawInput；//UserInput的成员变量
std:：string parseUserInput；//UserInput的成员变量
};

userInput.cpp

#include <iostream>                // Okay    
#include "userInput.hpp"           // Okay
#include "stringManipulation.hpp"  // Okay

using namespace std;   // Bad Practice

string branchCommand;  // non const local Global Variable - can be bad practice 

// Looks like a global function that is not a part of your class
string parseUserInput(){

    removeWhiteSpaces(rawInput);

    return branchCommand;   // returning global variable that isn't used?
}

#包括//好的
#包括“userInput.hpp”//OK
#包括“stringManipulation.hpp”//OK
使用命名空间std；//坏习惯
字符串branchCommand；//非常量局部全局变量-可能是不好的做法
//看起来像不是类的一部分的全局函数
字符串parseUserInput（）{
删除空白（rawInput）；
return branchCommand；//返回未使用的全局变量？
}

你是说

userInput.hpp

// Missing Header Guards Or #Pragma Once
#include <string>

class UserInput{
public:    
    std::string rawInput;        // Member Variable of UserInput      
    std::string parseUserInput;  // Member Variable of UserInput   
};

#ifndef USER_INPUT_HPP
#define USER_INPUT_HPP

#include <string>

class UserInput {
public:
    std::string rawInput; // Member Variable
    std::string parseUserInput(); // Now a Member Function that Returns a std::string
};

#endif // USER_INPUT_HPP

#include <iostream>
#include "userInput.hpp"
#include "stringManipulation.hpp"

std::string branchCommand; // Still a bad idea if not const or static

std::string UserInput::parseUserInput( /* should this take a string from the user? */ ) {
    removeWhiteSpaces( rawInput );

    return branchCommand; // ? ... Still not sure what you are returning.
}

\ifndef用户输入\u水电站
#定义用户输入HPP
#包括
类用户输入{
公众：
std:：string rawInput；//成员变量
std:：string parseUserInput（）；//现在是一个返回std:：string的成员函数
};
#endif//USER\u INPUT\u HPP

userInput.cpp

// Missing Header Guards Or #Pragma Once
#include <string>

class UserInput{
public:    
    std::string rawInput;        // Member Variable of UserInput      
    std::string parseUserInput;  // Member Variable of UserInput   
};

#ifndef USER_INPUT_HPP
#define USER_INPUT_HPP

#include <string>

class UserInput {
public:
    std::string rawInput; // Member Variable
    std::string parseUserInput(); // Now a Member Function that Returns a std::string
};

#endif // USER_INPUT_HPP

#include <iostream>
#include "userInput.hpp"
#include "stringManipulation.hpp"

std::string branchCommand; // Still a bad idea if not const or static

std::string UserInput::parseUserInput( /* should this take a string from the user? */ ) {
    removeWhiteSpaces( rawInput );

    return branchCommand; // ? ... Still not sure what you are returning.
}

#包括
#包括“userInput.hpp”
#包括“stringManipulation.hpp”
std:：string branchCommand；//如果不是常量或静态，这仍然是个坏主意
std:：string UserInput:：parseUserInput（/*应该从用户那里获取字符串吗？*/）{
删除空白（rawInput）；
return branchCommand；//？…仍然不确定返回的是什么。
}

避免

使用名称空间标准在您的代码中，我通常不会强制执行它，因为它是100%正确的代码，使用它仍然是不明智的，但是在某些情况下，如果它在函数定义中，它是可以的；但我建议永远不要在全局范围内使用它在您的代码中，我通常不会强制执行它，因为它是100%正确的代码，使用它仍然是不明智的，但是在某些情况下，如果它在函数定义中，它是可以的；但我建议永远不要在全球范围内使用它。