标签: member-variables

 // In A.h
 class A
 {
  public:
    enum eMyEnum{ eOne, eTwo, eThree };
  public:
    A(eMyEnum e);
 }

 // In B.h
 #include "A.h"
 class B
 {
    B();
    private:
       A memberA;
 }

 // In B.cpp
#include "B.h"
 B::B(void) : memberA(A::eOne)
 {}

'memberA'的声明使用g ++编译器给出了编译错误:错误:'A :: eOne'不是类型

我怎么能克服这个？我只需要创建一个不带参数的默认构造函数吗？

我正在尝试实现一个将Lambda回调作为参数的c ++函数.问题是,回调是从同一个(被调用的)类中的另一个函数异步启动的.因此,我需要将Lambda存储在一个成员变量中,以便可以通过需要启动回调的异步函数来访问它.

我尝试了所有我能想到的方法来使用成员变量声明,设置和调用Lambda,但代码总是在赋值或调用中崩溃.

这是我正在尝试做的一个被剥离的版本.

声明功能:

void function(const std::function<void()>callback);

从主代码调用函数:

myClass->function([](){cout << "Callback called";});

如果我callback从内部执行function它工作正常,但我找不到一种方法将它存储在一个成员变量(例如m_callback)中,并从同一个类的另一个函数调用它.

什么是成员变量？成员变量和实例变量是一回事吗？

实例变量是在类中声明并在整个代码中访问的变量，对吗？

我有一个带有复制构造函数的简单容器类.

您是否建议使用getter和setter,或直接访问成员变量？

public Container 
{
   public:
   Container() {}

   Container(const Container& cont)          //option 1
   { 
       SetMyString(cont.GetMyString());
   }

   //OR

   Container(const Container& cont)          //option 2
   {
      m_str1 = cont.m_str1;
   }

   public string GetMyString() { return m_str1;}       

   public void SetMyString(string str) { m_str1 = str;}

   private:

   string m_str1;
}

• 在示例中,所有代码都是内联的,但在我们的实际代码中没有内联代码.

更新(09年9月29日):

其中一些答案写得很好但是他们似乎忽略了这个问题的重点:

• 这是一个简单的人为例子,讨论使用getter/setter和变量

• 初始化列表或私有验证器函数实际上不是这个问题的一部分.我想知道这两种设计是否会使代码更容易维护和扩展.

• 一些ppl在这个例子中专注于字符串,但它只是一个例子,想象它是一个不同的对象.

• 我不关心表现.我们不是在PDP-11上编程

我是C++的新手,我遇到了设置主体系结构的问题.我学会了如何在C#中使用这个特定的体系结构,但我无法在C++中使用它.我的问题如下:我有2个对象.我希望这些对象彼此"了解",所以我希望将这两个对象作为成员变量引用.

考虑一下:

//main.cpp:
#include "Object1.h"
#include "Object2.h"

Object1 *obj1;
Object2 *obj2;

...

obj1 = new Object1(obj2);
obj2 = new Object2(obj1);

...


//Object1.h

#ifndef OBJECT1_H
#define OBJECT1_H

#include "Object2.h"

class Object1 {
    public:
    Object1(Object2*);

    Object2 *obj;
}

#endif


//Object2.h

#ifndef OBJECT2_H
#define OBJECT2_H

#include "Object1.h"

class Object2 {
    public:
    Object2(Object1*);

    Object1 *obj;
}

#endif

然而这是不可能的.因为如果没有ifndef的东西你就会有这种无休止的迭代,包括每个人的.h文件.但是对于ifndef,其中一个对象没有包含其他类定义,也不知道它应该创建什么对象.整个问题不会出现在C#中,因为您不必包含.h文件.你甚至没有.h文件:P.当你创建一个新类时,每个其他类都知道这个类的存在.但是在C++中,你必须包含特定类的.h才能生成这个类的对象(或者甚至是引用).

所以,我的问题是.如何将2个对象作为彼此的引用作为自己的成员变量？

感谢您的关注!

干杯,

Maxim Schoemaker

在获得有关这个问题的帮助后，我被引导进行更好的调试。在这个过程中，我发现我的问题是这样的：

在 C++ 中工作时，尝试将类的成员变量设置为一个值是可行的，但在循环时则不行。我已将我的代码（遵循）减少到我认为最简单的代码，因为仍然会产生错误。

调用类 Mover 的函数来修改变量 pMovXPOS，然后可以在同一范围内（在该函数内）并从调用它的位置（在循环内）检索更新后的变量。然而，在循环时，变量似乎被重置为其原始值。

我在这里发布了完整的测试代码。问题出在Main-test.cpp文件的RunWorld()函数中。如果编译并运行，您应该看到显示变量更改然后重置的输出。

这是范围问题吗？建设/破坏问题？指针/引用问题？我不知道从哪里开始（除了更好的调试）。

（由于我是 C++ 新手，我确信我使用的样式和/或方法存在一些明显的问题。如果有任何主要禁忌，请随意指出。）

预先感谢您的任何帮助！

//Main-Test.cpp
#include "Globals-Test.h"
#include "Mover-Test.h"

std::vector < Mover > AllMovers;

long SysCounter;

Mover CreateNewMover() {
Mover TempMover;

    TempMover.setXPOS(5);
    TempMover.setYPOS(10);

    return TempMover;

}

void RunWorld() {
Mover TempMover;
unsigned int iMoverLoop;

    srand ( time(NULL) );

    AllMovers.push_back(CreateNewMover());

    for (SysCounter = 0; SysCounter <= 50; SysCounter++) {
        for (iMoverLoop = 0; iMoverLoop < AllMovers.size(); iMoverLoop++) {
            std::cout << "Loop #:" << SysCounter << std::endl;
            TempMover = AllMovers.at(iMoverLoop);
            std::cout …

我有abstract class一个变量,如下所示:

public abstract class MyAbstractClass {

    int myVariable = 1;

    protected abstract void FunctionThatUsesMyVariable();
}

然后,当我class通过以下代码实例化我时,myVariable无法看到:

MyAbstractClass myClass = new MyAbstractClass() {

    @Override
    protected void FunctionThatUsesMyVariable() {
        // TODO Auto-generated method stub
    }
}; 

我做错了什么,我怎样才能实现我想要实现的目标？

我对Java中的局部变量和成员变量有疑问.情况是:有时如果我定义一个局部变量,那么该变量必须被传递到几个级别的方法调用.我经常想,为什么我要为类定义一个成员变量,以便变量在类中的任何位置都可用.类的成员变量就像一个可在类中的任何位置访问的全局变量.

1. 这种情况的最佳做法是什么？或者什么是正确的做法？

2. 如果我将它定义为成员变量,它应该是静态还是非静态变量？

假设我有一个活动,它包含一个TextView.我可以将TextView初始化为成员变量或局部变量.这些与初始化之间有任何记忆明智的区别吗？

示例: 具有本地视图引用的活动:

 public class MainActivity extends Activity{

    @OVerride
    public void onCreate(Bundle b){
       TextView textView = (TextView)findViewById(R.id.my_text_view_id);
    }
}

成员视图参考的活动:

 public class MainActivity extends Activity{
    TextView mTextView;

    @OVerride
    public void onCreate(Bundle b){
       mTextView = (TextView)findViewById(R.id.my_text_view_id);
    }
}

我正在尝试编写一个非常简单的专用类模板，它具有一个成员变量，并且可以在特殊情况下以不同的方式打印该成员变量。我知道这个例子没什么用，但它很好地说明了这个问题。

当专门化类模板时，类的专门化似乎不共享相同的成员变量，因此以下代码将无法编译...

#include <iostream>
#include <string>

// Class template
template <typename T>
struct S
{
    S(const T& t)
        : t(t)
    {}

    void print()
    {
        std::cout << t << std::endl;
    }
private:
    T t;
};

// Specialization
template <>
struct S<std::string>
{
    void print()
    {
        // ERROR: "t" is not defined in this context
        std::cout << "string: " << t << std::endl;
    }
};

这表明我需要为每个专业化编写一个单独的构造函数，并为每个专业化有一个单独的成员变量t，如果我有很多专业化，它会很快成为大量重复的代码和工作。

如果我说的是真的，那么在专门的类模板中完全使用成员变量是不好的做法吗？是否有任何替代方法可以减少代码重复？