C++学习概述

1.c++ 为啥需要头文件

如果您刚开始使用 C++，您可能想知道为什么C++需要 #include 头文件，以及为什么一个程序要拥有多个 .cpp 文件。 原因很简单：

a) 减少编译时间
随着程序的增长，您的代码也会增长，如果所有内容都在一个文件中，那么每次进行任何微小更改时都必须完全重新编译所有内容。对于小程序来说，这似乎没什么大不了的（实际上也不是），但是当您有一个合理大小的项目时，编译整个程序可能需要几分钟的时间。

你能想象在每次小改动之间都要等那么久吗？就像下面的情况：

编译/等待 8 分钟/“我靠，忘记分号”/编译/等待 8 分钟/调试/编译/等待 8 分钟/。。。。。。

b) 使代码更有条理
如果您将不同的功能模块分离到不同的文件中，那么在您想要进行修改时，更容易找到您正在寻找的代码。

（否则你需要盯着它并记住它是如何使用的、以及它是如何工作的）

c) 接口与实现分离
如果您不明白这意味着什么，请不要担心，我们将在本文中看到它的实际应用。

以上都是优点，但很明显缺点是，如果您不了解它是如何工作的，这反而会给你带来麻烦。

（但实际上，随着项目变得越来越大，头文件比很多其他的替代方案更简单）

C++ 程序的构建有两个阶段过程。

首先，每个源文件都是独立编译的。 编译器为每个编译的源文件生成中间文件。 这些中间文件通常称为对象文件(Linux中后缀为.o，Windows中后缀为.obj)——但不要将它们与代码中的对象混淆。 一旦所有文件都被单独编译，链接器将所有目标文件链接在一起，从而生成最终的二进制文件（程序）。

这意味着每个源文件都与其他源文件分开编译。因此，就编译而言，“a.cpp”对“b.cpp”内部发生的事情一无所知。
这里有一个简单的例子来说明：

// in myclass.cpp

class MyClass
{
public:
  void foo();
  int bar;
};

void MyClass::foo()
{
  // do stuff
}

// in main.cpp

int main()
{
  MyClass a; // Compiler error: 'MyClass' is unidentified
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

即使在您的程序中(myclass.cpp)声明了 MyClass，它也没有在 main.cpp 中声明，因此当您编译 main.cpp 时会出现该错误。

这就是头文件的来源。头文件允许您使接口（在本例中为 MyClass 类）对其他 .cpp 文件可见，同时将实现（在本例中为 MyClass 的成员函数体）保留在其自己的 . .cpp 文件。 同样的例子，但略有调整：

// in myclass.h

class MyClass
{
public:
  void foo();
  int bar;
};

// in myclass.cpp
#include "myclass.h"

void MyClass::foo()
{
}

//in main.cpp
#include "myclass.h"  // defines MyClass

int main()
{
  MyClass a; // no longer produces an error, because MyClass is defined
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include 语句基本上类似于复制/粘贴操作。 编译器将在编译文件时将#include 行“替换”为您包含的文件的实际内容。

2.c++ new对象

#include 
#include "hello.hpp"

using namespace std;
using std::cout;
using std::endl;

class Person {
public:
    int age;
    string name;
    Person(int a, string n) : age(a), name(n) {}
    void show(string n) const {
        cout << "This is method show,n=" << n << endl;
    }
};

int main() {
    cout << "Hello, World!" << endl;
    //口语中的指针其实指的是指针变量。指针变量里面存放的是地址，而通过这个地址，就可以找到一个内存单元。
    //&a——就是通过取地址操作操作符，取出a的地址，所以，&a就是代表a的编号，即：&a就是a的地址
    //b是地址，使用*b来取对应值
    int a = 10;
    int *b = &a;
    cout << "sizeof:" << sizeof(b) << "value:" << *b << ",a的address:" << &a << "," << b << ",b的address:" << &b
         << endl;

    int arrPoint[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int *p = arrPoint;                  //指针指向数组首地址
    p++;                                //指针向前移动4个字节，指向数组第二个元素
    cout << "值:" << *p << endl;        //p是地址，使用*p来取对应值

    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    //获取数组在内存中的首地址
    cout << "数组中第一个元素的地址:" << &arrPoint[0] << endl;
    cout << "数组中第一个元素的地址:" << &arrPoint[1] << endl;

    //采用new运算符调用
    Hello *hello = new Hello();
    hello->show();

    //创建的对象会放入栈空间
    Hello hello2;
    hello2.show();

    Person *p2 = new Person(18, "jack");
    cout << p2->age << p2->name << endl;
    p2->show("szp");

    return 0;

    string s("hello world");
    string::iterator it = s.begin();
    while (it != s.end()) {
        cout << *it;
        it++;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

1.采用类名直接访问，创建的对象会放入栈空间，让其与局部变量在一定意义上等价起来。
2.采用new运算符调用
（1）创建的对象会放入堆空间，不会自动清除，需要手动detele清除，不然会产生内存泄漏问题。
（2）在堆中申请开辟一块区域，与java相同，java纯面向对象的原因之一就是对象都保存在堆中，不会出现在栈中。

3. << 符号

4. << 在c++中有两种用途。
   1.用于C++的I/O流的输入和输出中的输出，也就是用在cout中，它是一个提取运算符，表示把一个东西输出到标准输出设备比如显示器，如：cout<<“哈哈，哈哈！”，此时就会在屏幕上输出：哈哈，哈哈！和输入流中的cin>>相对应。<<运算符是可以重载的。
   2.它作为逻辑运算中的左移运算符，表示把它左边的操作数左移n位，比如 a<<3;就表示把a的二进制表示方式左移3位，a左边移动的三位丢弃，后边空出的三位用0补充。