VS2015建立一个完整的c++工程：头文件.h 源文件.cpp，自动生成类

Posted 2021-02-21 梅长苏枫笑

https://blog.csdn.net/weixin_40539125/article/details/81430801

 

 

打开VS2015 ，新建VS win32工程，前面步骤很简单，不再阐述

下面直接开始：

新建一个VC++ win32的程序，

在源文件加下添加.cpp文件，一般放main函数

1.  
   #include <iostream>
2.  
   #include <locale>
3.  
   #include "human.h"
4.  
   using namespace std;
5.  
    
6.  
    
7.  
   int main()
8.  
   { 
9.  
   Human Tom;
10.  
    Tom.A(160);
11.  
    people zhangsan;
12.  
    zhangsan.B(160);
13.  
     
14.  
     
15.  
    //cout<<Tom.printf();
16.  
    }

 

在头文件中添加.h文件（human.h），一般是定义的类   

1.  
   class Human
2.  
   {
3.  
   public:
4.  
   void A(int w);
5.  
   private:
6.  
   int *i;
7.  
   };
8.  
    
9.  
    
10.  
    class people
11.  
    {
12.  
    public:
13.  
    void B(int j);
14.  
    int num;
15.  
    private:
16.  
    int numa;
17.  
    };

头文件中的.cpp文件放类的构造函数

1.  
   #include "human.cpp"
2.  
    
3.  
    
4.  
    
5.  
   #include <iostream>
6.  
   #include "human.h"
7.  
   using namespace std;
8.  
   void Human::A(int w)
9.  
   {
10.  
    cout << w << endl;
11.  
    }
12.  
    void people::B(int w)
13.  
    {
14.  
    w -= 100;
15.  
    cout << w << endl;
16.  
    }
17.  
     

然后在源文件下的main函数的要加上类的声明头文件，头文件.cpp也要添加类声明的头文件

i

 

注意：头文件中定义的类，在与之同名的c文件中要做声明，类的构造函数和析构函数要么显示定义，也要显示的声明，哪怕这些函数里面没有执行的内容，空的也要写出来，否则会编译通不过，要么类的构造函数和析构函数都不写，类默认产生不执行任何程序的构造函数和析构函数

反正一条：对于类里面的析构函数和构造函数只要定义了，必须要声明，函数为空也可以

 

下面补充一下在VS里面多文件系统（即有多个头文件和cpp文件），使用VS来自动生成类，

1、项目右击->添加->类

输入类名后，h文件和cpp文件自动填充好，而且生成的类的构造函数、析构函数、包含头文件全都有了

如下图：

生成的代码：

h文件

1.  
   #pragma once
2.  
    
3.  
    
4.  
   class Clock
5.  
    
6.  
   {
7.  
    
8.  
   public:
9.  
    
10.  
    Clock();
11.  
     
12.  
    ~Clock();
13.  
     
14.  
    };

cpp文件

1.  
   #include "Clock.h"
2.  
    
3.  
    
4.  
   Clock::Clock()
5.  
    
6.  
   {
7.  
    
8.  
   }
9.  
    
10.  
     
11.  
    Clock::~Clock()
12.  
     
13.  
    {
14.  
     
15.  
    }
16.  
     

 

上面都是空的，下面在里面填上我们的函数

2、在类里面放上我们的函数

h文件添加函数后

1.  
    
2.  
    
3.  
   #pragma once
4.  
    
5.  
   #include <iostream>
6.  
    
7.  
   using namespace std;
8.  
    
9.  
    
10.  
    class Clock
11.  
     
12.  
    {
13.  
     
14.  
    public:
15.  
     
16.  
    Clock();
17.  
     
18.  
    void SetTime(int NewH, int NewM, int NewS); //三个形参均具有函数原型作用域
19.  
     
20.  
    void ShowTime();
21.  
     
22.  
    ~Clock();
23.  
     
24.  
    private:
25.  
     
26.  
    int Hour, Minute, Second;
27.  
     
28.  
    };

cpp文件添加函数后：

1.  
   #include "Clock.h"
2.  
    
3.  
   Clock::Clock()
4.  
    
5.  
   {
6.  
    
7.  
   Hour = 0;
8.  
    
9.  
   Minute = 0;
10.  
     
11.  
    Second = 0;
12.  
     
13.  
     
14.  
    }
15.  
     
16.  
    void Clock::SetTime(int NewH, int NewM, int NewS)
17.  
     
18.  
    {
19.  
     
20.  
    Hour = NewH;
21.  
     
22.  
    Minute = NewM;
23.  
     
24.  
    Second = NewS;
25.  
     
26.  
    }
27.  
     
28.  
    void Clock::ShowTime()
29.  
     
30.  
    {
31.  
     
32.  
    cout << Hour << ":" << Minute << ":" << Second << endl;
33.  
     
34.  
    }
35.  
     
36.  
     
37.  
    Clock::~Clock()
38.  
     
39.  
    {
40.  
     
41.  
    }
42.  
     
43.  
     
44.  
     

 

3、在main里面添加我们的类包含头文件

#include "Clock.h"   //头文件

1.  
    
2.  
   Clock g_Clock;
3.  
    
4.  
   int main() //主函数
5.  
    
6.  
   {
7.  
    
8.  
   cout << "文件作用域的时钟类对象:" << endl;
9.  
    
10.  
    //引用具有文件作用域的对象：
11.  
     
12.  
    g_Clock.ShowTime();
13.  
     
14.  
    g_Clock.SetTime(10, 20, 30);
15.  
     
16.  
     
17.  
    Clock myClock(g_Clock); //声明具有块作用域的对象myClock，并通过默认拷贝构造函数用g_Clock初始化myClock
18.  
     
19.  
    cout << "块作用域的时钟类对象:" << endl;
20.  
     
21.  
    myClock.ShowTime(); //引用具有块作用域的对象
22.  
     
23.  
    return 0;
24.  
     
25.  
    }

????

运行结果：

over！！！