C++ 我应该怎样写课程？C++；

嘿。。我真的不明白。我读了一个关于C++课程的教程，我没有得到一些东西： 在我所看到的每个示例和教程中，函数从来都不是在类中编写的！例如，为什么要编写这样的类：

#include <iostream>

using namespace std;

class test
{
    private:
        int x, y;
    public:
        test (int, int);
        int tester () {return x + y; }
};

test::test (int a, int b)
{
    x = a;
    y = b;
}

int main()
{
    test atest (3, 2);
    test atest2 (2, 6);

    cout << "test1: " << atest.tester() << endl;
    cout << "test2: " << atest2.tester() << endl;

    return 0;
}

#include <iostream>

using namespace std;

class test
{
    private:
        int x, y;
    public:
        void set_values (int,int);
        int testfunc () {return x + y; }
};

void test::set_values (int a, int b)
{
    x = a;
    y = b;
}

int main()
{
    test tester;

    tester.set_values (3, 2);

    cout << "test1: " << tester.testfunc() << endl;

    return 0;
}

#include <iostream>

using namespace std;

class test
{
    public:
        int tester (int x, int y) { return x + y; }
};

int main()
{
    test atest;

    cout << atest.tester(3, 2) << endl;

    return 0;
}

#包括
使用名称空间std；
课堂测试
{
私人：
int x，y；
公众：
测试（int，int）；
int tester（）{返回x+y；}
};
测试：：测试（int a，int b）
{
x=a；
y=b；
}
int main（）
{
试验（3,2）；
试验2（2，6）；
cout传统上，在类定义中定义的方法是内联的。也就是说，在执行它们时不进行调用。但是，对于较新的编译器，关于内联的规则更复杂。然而，我认为一个好的经验法则仍然是在头中定义希望内联的方法

您不需要私有成员。类提供了一种将代码组织到逻辑单元的方法。通过将成员私有化，您可以将该逻辑封装到类中。好处是，您可以专注于这些私有成员，而无需担心应用程序的其他部分会做什么，因为应用程序的其他部分不会l直接访问这些成员。
传统上，在类定义中定义的方法是内联的。也就是说，在执行它们时不进行调用。但是，对于较新的编译器，关于内联的规则更加复杂。不过，我认为一个好的经验法则仍然是在头中定义希望内联的方法

您不需要私有成员。类提供了一种将代码组织到逻辑单元的方法。通过将成员私有化，您可以将该逻辑封装到类中。好处是，您可以专注于这些私有成员，而无需担心应用程序的其他部分会做什么，因为应用程序的其他部分不会l直接访问这些成员。
如上所示，第一种书写方式允许您将函数定义（类接口）分离为头文件和函数声明（类实现）您可以在中了解有关头文件的更多信息。某些方法有好处，其中一种方法是在类中编写函数声明，但要获得这些好处，您的方法必须满足几个条件

私有成员允许您隐藏类的数据，以便只有该类可以操作该数据。它提供了一种处理正确且重要的面向对象编程概念的方法。封装将所有对某个数据段进行操作的方法捆绑到一个类中，这恰好有助于实现良好的、清晰的软件设计

<> >析构函数。如果你对C++析构函数感到困惑，你可能想在C++中读到一个好的C++书籍中的内存，比如加速C++。
 < p>第一个写作风格，如上面所示，允许你把函数定义（你的类接口）分成一个头文件和函数声明。（您的类实现）写入.cpp文件中。您可以在中了解有关头文件的更多信息。某些方法有好处，其中一种方法是在类中编写函数声明，但要获得这些好处，您的方法必须满足几个条件

私有成员允许您隐藏类的数据，以便只有该类可以操作该数据。它提供了一种处理正确且重要的面向对象编程概念的方法。封装将所有对某个数据段进行操作的方法捆绑到一个类中，这恰好有助于实现良好的、清晰的软件设计

<> >析构函数。如果你对C++析构函数感到困惑，你可能想在C++的一本好的C++书籍中读内存，比如加速C++。
 ，格雷戈说你真的需要读一本书。
我通常应该如何编写课程？

类允许您将数据和作用于它们的函数组合成一件事

为什么我需要私人会员？？

私有成员只能由类中的函数访问，这使您可以控制数据在类中的存储方式，而类的用户不能执行您不期望的操作

何时以及如何使用析构函数？

当你有一些东西需要清理，而你的对象不再需要时，一个文件被关闭或内存被释放。
正如格雷格所说，你真的需要读一本书

我通常应该如何编写课程？

类允许您将数据和作用于它们的函数组合成一件事

为什么我需要私人会员？？

私有成员只能由类中的函数访问，这使您可以控制数据在类中的存储方式，而类的用户不能执行您不期望的操作

何时以及如何使用析构函数？

当对象不再需要时，如果有需要清理的内容，则会关闭文件或释放内存。
私有成员会隐藏类的内部，以防外部操作。这允许类的编写者更改内部实现细节，而无需担心破坏其他代码，并允许ass以确保它保持在有效状态。（将具有支腿长度的三角形视为公共数据成员：无法阻止其他代码将支腿长度设置为2、3和7。）

析构函数通常应该释放对象所拥有的资源，比如文件句柄、数据库连接、堆上的内存块。如果对象没有这样的资源，通常不需要您编写析构函数。如果有，您可能还需要编写自己的复制构造函数和赋值运算符。（可以使用“智能指针”来引用内存块，它们有自己的定义。）
void example(Test obj) {
  if (something) {
    process(obj.tester());
  }
}

int main() {
  int x, y;  // Imagine these are assigned to user input.
  Test obj (x, y);
  example(obj);  // Obj.tester may or may not be used.  If the x + y was not
  // separated, then you couldn't "maybe use" it.
  return 0;
}

struct Test {
  Test(int x, int y)  // Use the same names rather than inventing 'a' and 'b'.
  : _x (x), _y (y)
  {}

  int tester() const { return _x + _y; }
  // Move outside the class when needed, if at all -- and it won't be needed
  // for a function like this.
  // Because this doesn't modify anything, it's suitable to be const, which
  // means it can be called on a const Test object.

  int _x, _y;
  // Technically public, but with a "non-public name".  Mark private as you
  // wish, or as the design settles down.
};

int Employee::GetDollars(int employee_id); 

Image i;
i.loadFromFile("myFace.jpg");

Image i;
i.preparePixelBuffer();
memset(i.pixelBuffer, 0, i.pixelBufferSize);
FILE* fp = fopen("myFace.jpg", "r");
bool doneLoading = false;
while (!doneLoading)
...