Question

我正在学习OOP的第一步。这是我无法解决的第一个问题。此类中的max函数应返回最多两个数字。我想将数字保存在私有范围和公共范围内的函数中。但是当我想在公共范围内使用来自struct data{}的变量时，编译器会说未声明变量。请告诉我为什么我会收到这些错误。

class myclass{
private:
   struct data{
       int q ;
       int w;
   };

public:
   void get(int a, int b){
      struct data = {a , b}; // here I want to pass the variables to data struct
   }
   int max (){              // this function returns the biggest number 
      if(q>w)
         return q;
         else 
            return w;
   } 

};

Answer 1

struct data{
    int q ;
    int w;
};

仅声明类型，而非对象，因此q内的任何位置都没有w和class成员实例。您需要声明struct的实例：

struct {
     int q;
     int w;
} data;

然后，您可以将max写为：

int max()
{
    if (data.q > data.w)
        return data.q;
    else 
        return data.w;
}

（我不知道你的get方法应该做什么，所以我没有替代方法。）

Answer 2

在C ++中，“class”和“struct”接近成为同义词（同一件事）。唯一的区别是“结构”默认为“公共”可访问性，而“类”默认为私有。

一旦你理解了这一点，你应该明白你正在做的是在你的班级中定义一个子类型。

class myclass {
private: // <- not required, you already said that by saying "class".
    struct data {
        // <-- this is a class definition with "public:" just here.
        ...
    };
};

C ++允许您嵌套类/结构定义，以便您可以创建编组参数或返回值的结构。

class Database {
    class Result { ... };
};

...

class Exam {
    class Result { ... };
};

这两个结果类通过Database :: Result和Exam :: Result而不仅仅是“Result”来避免命名空间冲突。

但是 - 这些只是定义。它们 - 如图所示 - 对外围类没有任何影响，即：它们不被用于在课堂上添加成员。

您的代码：

class myclass{
private:
   struct data{  // <-- this is a TYPE declaration, struct myclass::data
       int q ;   //
       int w;    // 
   };            // <-- no member name here so does not affect myclass itself.

public:
   void get(int a, int b){
      struct data = {a , b}; // here I want to pass the variables to data struct
   }
   int max (){              // this function returns the biggest number 
      if(q>w)
         return q;
         else
            return w;
   }

};

声明类型“myclass :: data”但不向类中添加类型为“myclass :: data”的成员。 “struct data =”这一行是非法的，您正在尝试将值分配给TYPE。

它应该写成

class MyClass {
    int m_q;
    int m_w;

public:
    void set(int q, int w) {
        m_q = q;
        m_w = w;
    }

    int max() const {
        return (m_q > m_w) ? m_q : m_w;
        // or #include <algorithm> and return std::max(m_q, m_w);
    }
};

你只需要提升q＆amp;如果要在类的范围之外重用该结构定义，请将w转换为结构，例如：在派生或并行类中，您可能希望添加更多相同的类型的事物，在这种情况下，您可以执行以下操作，但如果您这样做 this 确切的方式，你最终会打破自己打破封装：

class MyClass {
public:
    struct Data {
        int m_q;
        int m_w;
    };

private:
    Data m_data;

    void set(int q, int w) {
        m_data.m_q = q;
        m_data.m_w = w;
    }

    int max() const {
        return (m_data.m_q > m_data.m_w) ? m_data.m_q : m_data.m_w;
    }
};

更好的方法是，如果成员的这种耦合需要在某种程度上在外部可见，那么：

class MyClass {
public:
    class Data {
        int m_q;
        int m_w;
    public:
        Data() : m_q(0), m_w(0) {}
        Data(int q, int w) : m_q(0), m_w(0) {}

        void set(int q, int w) {
            m_q = w;
            m_w = w;
        }

        int q() const { return m_q; }
        int w() const { return m_w; }

        int max() const { return (m_q > m_w) ? m_q : m_w;
    };

private:
    Data m_data;

public:
    MyClass() : m_data() {} // or = default
    MyClass(int q, int w) : m_data(q, w) {}
    MyClass(const Data& data) : m_data(data) {}

    // Read-only access
    const Data& data() const { return m_data; }
    // To allow write access, e.g. for set:
    Data& data() { return m_data; }
};

对于这样一个简单的案例来说，这有点过分，但欢迎使用C ++：样板语言。

Answer 3

您已定义了结构，但没有该类型的对象。你应该声明一个对象，你不会得到任何错误。

class myclass{
private:
   struct data{
       int q ;
       int w;
   }var;

public:
   void get(int a, int b){
     var .q= a;
    var.w=b; // here I want to pass the variables to data struct
   }
   int max (){              // this function returns the biggest number 
      if(var.q>var.w)
         return var.q;
         else 
            return var.w;
   } 

};

在课堂上制作一个结构

3 个答案: