[已解决]C++的.h里面的函数声明规则不太懂

i你哟

下棉函数中为什么有三个函数是放在类的外面声明的，而还有几个是放在类的public里面声明的，而最下面的还有一些函数没有声明，这是为什么，声明有什么规则吗？谢谢大家（这是一个complex的一个类）
#ifndef __MYCOMPLEX__
#define __MYCOMPLEX__

class complex;
complex&
  __doapl (complex* ths, const complex& r);///////三个函数是放在类的外面声明
complex&
  __doami (complex* ths, const complex& r);
complex&
  __doaml (complex* ths, const complex& r);


class complex
{
public:
  complex (double r = 0, double i = 0): re (r), im (i) { }///////public里面声明
  complex& operator += (const complex&);
  complex& operator -= (const complex&);
  complex& operator *= (const complex&);
  complex& operator /= (const complex&);
  double real () const { return re; }
  double imag () const { return im; }
private:
  double re, im;

  friend complex& __doapl (complex *, const complex&);
  friend complex& __doami (complex *, const complex&);
  friend complex& __doaml (complex *, const complex&);
};


inline complex&
__doapl (complex* ths, const complex& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}

inline complex&
complex::operator += (const complex& r)
{
  return __doapl (this, r);
}

inline complex&
__doami (complex* ths, const complex& r)
{
  ths->re -= r.re;
  ths->im -= r.im;
  return *ths;
}

inline complex&
complex::operator -= (const complex& r)
{
  return __doami (this, r);
}

inline complex&
__doaml (complex* ths, const complex& r)
{
  double f = ths->re * r.re - ths->im * r.im;
  ths->im = ths->re * r.im + ths->im * r.re;
  ths->re = f;
  return *ths;
}

inline complex&
complex::operator *= (const complex& r)
{
  return __doaml (this, r);
}

inline double
imag (const complex& x)
{
  return x.imag ();
}

inline double
real (const complex& x)
{
  return x.real ();
}

inline complex
operator + (const complex& x, const complex& y)
{
  return complex (real (x) + real (y), imag (x) + imag (y));
}

inline complex
operator + (const complex& x, double y)
{
  return complex (real (x) + y, imag (x));
}

inline complex
operator + (double x, const complex& y)
{
  return complex (x + real (y), imag (y));
}

inline complex
operator - (const complex& x, const complex& y)
{
  return complex (real (x) - real (y), imag (x) - imag (y));
}

inline complex
operator - (const complex& x, double y)
{
  return complex (real (x) - y, imag (x));
}

inline complex
operator - (double x, const complex& y)
{
  return complex (x - real (y), - imag (y));
}

inline complex
operator * (const complex& x, const complex& y)
{
  return complex (real (x) * real (y) - imag (x) * imag (y),
                           real (x) * imag (y) + imag (x) * real (y));
}

inline complex
operator * (const complex& x, double y)
{
  return complex (real (x) * y, imag (x) * y);
}

inline complex
operator * (double x, const complex& y)
{
  return complex (x * real (y), x * imag (y));
}

inline complex//？
operator / (const complex& x, double y)
{
  return complex (real (x) / y, imag (x) / y);
}

inline complex
operator + (const complex& x)
{
  return x;
}

inline complex
operator - (const complex& x)
{
  return complex (-real (x), -imag (x));
}

inline bool
operator == (const complex& x, const complex& y)
{
  return real (x) == real (y) && imag (x) == imag (y);
}

inline bool
operator == (const complex& x, double y)
{
  return real (x) == y && imag (x) == 0;
}

inline bool
operator == (double x, const complex& y)
{
  return x == real (y) && imag (y) == 0;
}

inline bool
operator != (const complex& x, const complex& y)
{
  return real (x) != real (y) || imag (x) != imag (y);
}

inline bool
operator != (const complex& x, double y)
{
  return real (x) != y || imag (x) != 0;
}

inline bool
operator != (double x, const complex& y)
{
  return x != real (y) || imag (y) != 0;
}

#include <cmath>

inline complex
polar (double r, double t)
{
  return complex (r * cos (t), r * sin (t));
}

inline complex
conj (const complex& x)
{
  return complex (real (x), -imag (x));
}

inline double
norm (const complex& x)
{
  return real (x) * real (x) + imag (x) * imag (x);
}

#endif   //__MYCOMPLEX__

最佳答案

月排行榜 / 总排行榜

Mike_python小

2023-9-28 18:57:20

i你哟 发表于 2023-9-28 13:54
非常感谢，我还想问一下，1如何看他是否是类的内部函数，像这个
inline complex&
__doapl (complex* th ...

1. 在您提供的代码中，`inline`关键字用于内联函数的声明。它表明函数的定义可以在每个调用点处进行内联展开，以避免函数调用的开销。在C++中，使用`inline`关键字来声明函数是为了告诉编译器该函数可以内联展开。

2. 关于成员函数的放置和访问权限的问题，一般有以下几点考虑：

- 如果某个成员函数需要访问类的私有成员，那么它应该被定义为类的成员函数，这样可以直接访问私有成员。
- 如果某个函数不需要访问类的私有成员，或者只需要访问公有成员，那么它可以被定义为类的外部函数，这样可以提高代码的可读性和灵活性。
- 使用`public`关键字将函数声明在类的公有部分，表示这些函数对外部代码可见，并允许通过类的实例进行访问。

请注意，`inline`关键字与成员函数的访问权限没有直接的关系。`inline`关键字只是用于函数的编译器指令，它告诉编译器对该函数进行内联展开。在成员函数中使用`inline`关键字时，它并不会自动将函数声明为公有成员，仍然需要根据访问权限进行声明。

希望能够解答您的问题，如果还有疑问，请随时提出。

跳转到最佳答案楼层

isdkz

这是一个C++的类定义，其中包含了类的声明和定义。在类的声明中，有三个函数是在类的外面声明的，这是因为它们是类的友元函数，它们需要访问类的私有成员变量，但是又不属于类的成员函数，所以需要在类的外面进行声明。而其他的函数则是类的成员函数，它们需要在类的public里面进行声明。至于最下面的一些函数没有声明，是因为它们是在类的内部定义的内联函数，不需要进行额外的声明。需要注意的是，这个类定义的头文件使用了宏定义来避免重复包含，这是一个常见的做法。

Mike_python小

C++中，函数的声明规则是在使用函数之前需要先进行声明，以告知编译器函数的存在和参数类型。对于类的成员函数，可以选择将函数声明放在类的内部（如public、private等）或者类的外部。

在给出的代码中，有三个函数__doapl、__doami和__doaml被放在了类的外面进行声明。这是因为这三个函数是类的友元函数，它们虽然与类有关联，但却不是类的成员函数。将它们放在类的外部进行声明可以更清晰地表达其与类的关系。

而其他的函数，如operator +=、operator -=等，被放在了类的public部分进行声明。这是因为它们属于类的成员函数，可以通过类的对象进行调用。

最后的一些函数，如imag、real等，没有在类中进行声明，而是直接定义在类的外部，并且使用了inline关键字。这样的函数通常是非成员函数，但与类有一定的关联性，因此可以直接定义在类的外部，并使用inline关键字使得函数体内联展开，提高效率。

总结起来，C++中函数的声明规则是根据函数与类的关系来确定放置的位置：非成员函数或友元函数可以放在类的外部进行声明，成员函数应该放在类的内部进行声明。同时可以在类外定义一些与类相关但不是成员函数的函数，并使用inline关键字进行标识。

球一个最佳答案谢谢啦！这对我非常重要！

i你哟

Mike_python小 发表于 2023-9-28 16:37
C++中，函数的声明规则是在使用函数之前需要先进行声明，以告知编译器函数的存在和参数类型。对于类的成员 ...

非常感谢，我还想问一下，1如何看他是否是类的内部函数，像这个
inline complex&
__doapl (complex* ths, const complex& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}
在这里也是有inline，按理说他也是内联函数呀，这是为什么
2为什么只有那几个放在了public，其他的放在外面的不可以放进去吗？（这里的有inline就可以不用声明了吗？那为什么public里面还需要声明呢？）

i你哟

Mike_python小 发表于 2023-9-28 16:37
C++中，函数的声明规则是在使用函数之前需要先进行声明，以告知编译器函数的存在和参数类型。对于类的成员 ...

非常感谢，我还想问一下，1如何看他是否是类的内部函数，像这个
inline complex&
__doapl (complex* ths, const complex& r)
{
  ths->re += r.re;
  ths->im += r.im;
  return *ths;
}
在这里也是有inline，按理说他也是内联函数呀，这是为什么
2为什么只有那几个放在了public，其他的放在外面的不可以放进去吗？（这里的有inline就可以不用声明了吗？那为什么public里面还需要声明呢？）

Mike_python小

i你哟 发表于 2023-9-28 13:54
非常感谢，我还想问一下，1如何看他是否是类的内部函数，像这个
inline complex&
__doapl (complex* th ...

1. 在您提供的代码中，`inline`关键字用于内联函数的声明。它表明函数的定义可以在每个调用点处进行内联展开，以避免函数调用的开销。在C++中，使用`inline`关键字来声明函数是为了告诉编译器该函数可以内联展开。

2. 关于成员函数的放置和访问权限的问题，一般有以下几点考虑：

- 如果某个成员函数需要访问类的私有成员，那么它应该被定义为类的成员函数，这样可以直接访问私有成员。
- 如果某个函数不需要访问类的私有成员，或者只需要访问公有成员，那么它可以被定义为类的外部函数，这样可以提高代码的可读性和灵活性。
- 使用`public`关键字将函数声明在类的公有部分，表示这些函数对外部代码可见，并允许通过类的实例进行访问。

请注意，`inline`关键字与成员函数的访问权限没有直接的关系。`inline`关键字只是用于函数的编译器指令，它告诉编译器对该函数进行内联展开。在成员函数中使用`inline`关键字时，它并不会自动将函数声明为公有成员，仍然需要根据访问权限进行声明。

希望能够解答您的问题，如果还有疑问，请随时提出。