C++学习6（10.7-10.8）-六虎

1.1 枚举

linux中文件从一个方位仿制到另一个方位：

cp logclass.cpp /home/zymaaacmx/codecpp_project/z8enum/logclass.cpp

cp -r /home/user/old_dir /home/user/new_dirf

仿制多个文件到方针目录

cp file1.txt file2.txt /home/user/Documents

留意：

假如方针文件或目录已经存在，cp 指令会提示是否覆盖。

假如方针方位不存在，cp 指令会主动创立该方位。

假如在仿制时要保留文件属性（如权限、具有者、时间戳），能够加上 -p 选项：cp -p source_file target_file。

#include <iostream>
enum Example : char
{
   A = 5,B = 1,C
};
int main()
{
   Example value = B;
   if(value == B)
   {
      std::cout << static_cast<int>(value) << std::endl;
      std::cout << static_cast<int>(Example::A) <<std::endl;
   }
   std::cin.get();
}

需求留意的是，在输出 Example::A 的值时，也需求运用 **static_cast<int>(Example::A)** 将 **char** 型的枚举值转换为整数进行输出。

#include <iostream>
class Log
{
public:
   enum Level
   {
      LeError = 0,LeWarning,LeInfo
   };/*const int LogLevelError = 0; const int LogLevelWarning = 1;*/
private:
   Level m_LogLevel = LeInfo;//int m_LogLevel;m_代表着这是一个私有的类成 员变量
public:
   void SetLevel(Level level)
   {
      m_LogLevel = level;
   }
   void Error(const char* message)
   {
      if (m_LogLevel >= LeError)
         std::cout << "[ERROR]:" << message << std::endl;
   }
   void Warm(const char* message)
   {
      if (m_LogLevel >= LeWarning)
         std::cout << "[WARNING]:" << message << std::endl;
   }
   void Info(const char* message)
   {
      if (m_LogLevel >= LeInfo)
         std::cout << "[INFO]:" << message << std::endl;
   }
};
int main()
{
   Log log;
   log.SetLevel(Log::LeError);
   //log.SetLevel(log.LogLevelWarning);//2是信息或者盯梢，
   log.Error("Helo!");
   log.Info("Hello!");
   log.Warm("Hello!");
   std::cin.get();
}

为什么是Log::LeError，而不能是log::LeError

Log::LeError 表明 Log 类的成员 LeError，能够理解为把 LeError 拼在 Log 的后边，表明它是 Log 类的一部分。而 log::LeError 则表明 log 目标的成员 LeError，这是非法的，由于 LeError 并不是一个目标的成员，而是一个类的成员。

成果：

1.2 结构函数（constructor）

结构函数是类中一种特别的成员函数，用于创立和初始化类的目标。结构函数的称号与类名相同，并且没有回来类型（包括 void），因此它们不能被显式调用，而是在创立目标时主动调用。
结构函数有以下几个特色：

结构函数在目标创立时主动调用，用于初始化目标的成员变量。

结构函数能够有参数，用于传递初始化目标所需的信息。

每个类都能够界说一个或多个结构函数，它们之间能够经过参数类型和个数的不同进行重载。

假如没有显式界说结构函数，编译器会生成一个默许的无参结构函数（假如没有其他结构函数界说的话）。

假如显式界说了结构函数，则默许结构函数将不再被生成。需求留意的是，假如界说了有参结构函数，但仍想要运用默许结构函数，能够经过显式声明一个无参结构函数来完结。

在Linux中对目录进行操作：

删去一个空的目录： rmdir 目录名
删去一个非空的目录： rm -r 目录名
更改目录的称号 mv 原目录名新目录名
留意，假如新目录名已存在，则会将原目录移动到新目录下作为子目录。假如要将目录移动到其他方位并更改称号，能够提供新的完整路径 mv old_dir /path/to/new_dir

#include

class Entity { public: float X,Y;
```
  void Init()
  {
     X = 0.0f;
     Y = 0.0f;
  }
  void Print()
  {
     std::cout << X << " , " << Y << std::endl;
  }
```
};

int main() { Entity e; e.Init(); std::cout << e.X << std::endl; e.Print(); Entity e1; e1.Init(); e1.Print();

std::cin.get(); }

每个类的实例都想取值相同的x,y。每次都调用Init() 比较麻烦。

#include <iostream>
class Entity
{
   public:
      float X,Y;
      //void Init()
      Entity()
      {
         X = 0.0f;
         Y = 0.0f;
      }
      void Print()
      {
         std::cout << X << " , " << Y << std::endl;
      }
};
int main()
{
   Entity e;
   //e.Init();
   std::cout << e.X << std::endl;
   e.Print();
   Entity e1;
   //e1.Init();
   e1.Print();
   std::cin.get();
}

相同的成果：

能够有许多结构函数，条件是参数不同。类似函数重载。

函数重载（Function Overloading）指的是在同一个效果域内，能够界说多个同名但参数列表不同的函数。经过函数重载，能够运用相同的函数名完结不同的功能。
函数重载的特色：

函数称号有必要相同。

参数列表有必要不同，能够经过参数的类型、数量或顺序进行区别。

回来类型能够相同也能够不同。

函数重载与函数的回来值类型无关。

#include <iostream>
class Entity
{
   public:
      float X,Y;
      //void Init()
      Entity()
      {
//         X = 0.0f;
  //       Y = 0.0f;
      }
      Entity(float x,float y)
      {
         X = x;//参数赋值给了成员变量
         Y = y;
      }
      void Print()
      {
         std::cout << X << " , " << Y << std::endl;
      }
};
int main()
{
   Entity e(10.0f,5.0f);
   //e.Init();
   std::cout << e.X << std::endl;
   e.Print();
   Entity e1;
   //e1.Init();
   e1.Print();
   Entity e2;
   e2.Print();
   std::cin.get();
}

成果：

留意：：：：：C++ 中有必要初始化，否则会出现不确定的值

也能够经过创立类删去默许的结构函数。

#include <iostream>
class Entity
{
   public:
      float X,Y;
      Entity()
      {
      }
      Entity(float x,float y)
      {
         X = x;//参数赋值给了成员变量
         Y = y;
      }
      void Print()
      {
         std::cout << X << " , " << Y << std::endl;
      }
};
class Log
{
public:
   float a,b;
   Log() = delete;//默许的结构函数被删去
   static void Write(Log& log)
   {
      std::cout << log.a << "    " << log.b << std::endl;
   }
};
int main()
{
   Log l{1.0f,2.0f};
//Log l;删去了默许结构函数，这意味着无法运用无参数的方法来创立 Log 目标。
   Log::Write(l);
   Entity e(10.0f,5.0f);
   std::cout << e.X << std::endl;
   e.Print();
   std::cin.get();
}

成果：

留意：

删去了默许结构函数，这意味着无法运用无参数的方法来创立 Log 目标。
运用列表初始化方法创立目标并初始化成员变量：分别赋值给 Log 目标 l 的成员变量 a 和 b。

还有两种结构函数：赋值结构函数和移动结构函数

赋值结构函数（Copy Constructor）和移动结构函数（Move Constructor）是 C++ 中的特别结构函数，用于创立目标的副本或进行资源的移动。

1 赋值结构函数：赋值结构函数被用于经过已存在的目标创立一个新目标。它一般用于以下状况：

界说：

ClassA(const ClassA& other)
{
    // 执行必要的操作，将 other 的值赋给当前目标
}
ClassA obj1; // 创立目标 obj1
ClassA obj2(obj1); // 运用赋值结构函数，创立目标 obj2，并将 obj1 的值赋给 obj2

在赋值结构函数中，参数类型为 const ClassA&，这表明运用常引证来防止不必要的复制。赋值结构函数一般会完结深复制，即在新目标的结构过程中仿制一切成员变量的值。

2 移动结构函数：移动结构函数用于将资源从一个目标移动到另一个目标，防止不必要的复制操作，进步功能。它一般用于以下状况：

ClassA(ClassA&& other)
{
    // 执行必要的操作，将 other 的资源移动到当前目标
}
ClassA obj1; // 创立目标 obj1
ClassA obj2(std::move(obj1)); // 运用移动结构函数，创立目标 obj2，并将 obj1 的资源移动到 obj2

在移动结构函数中，参数类型为 ClassA&&，这表明运用右值引证来接收需求移动的目标。移动结构函数一般会完结资源的搬运，比方指针的一切权搬运。

需求留意的是，假如一个类界说了移动结构函数，但没有界说赋值结构函数，那么该类只能进行移动操作，无法进行复制操作。

总结：赋值结构函数和移动结构函数都是特别的结构函数，用于创立目标的副本或进行资源的移动。赋值结构函数用于经过已存在的目标创立一个新目标，而移动结构函数用于将资源从一个目标移动到另一个目标。它们能够明显进步代码的功能和功率。

C++学习6（10.7-10.8）

1.1 枚举

1.2 结构函数（constructor）

相关文章

B端作品集就别用C端那套思路了

Nodejs 第二十六章（反向代理）

GitHub 一周热点汇总第8期(2024/01/28-02/03)

我在京东做研发 | 揭秘支撑京东万人规模技术人员协作的行云DevOps平台

作者信息