C++ (第五天)

循环

#include <iostream>
#include "Log.h"

int main()
{
    for (int i = 0; i < 5; i++)
    {
        Log("Hello World!");
    }
    std::cin.get();
}

for (int i = 0; i < 5; i++)

for循环的三部分

1. 在for循环之前执行一次 int i = 0;

2. 比较或者布尔值，执行每一次循环前会检验 i < 5;

3. 每次循环结束后执行的代码 i++；

int i = 0;
    for (; i < 5; )
    {
        Log("Hello World!");
        i++;
    }

    int i = 0;
    bool condition = true;
    for (; i < 5; )
    {
        Log("Hello World!");
        i++;
        if (!(i < 5))
            condition = false;
    }

while

 for (int i = 0; i < 5; i++)
    {
        Log("Hello World!"); 
    }

    Log("========================");

    int i = 0;
    while (i < 5)
    {
        Log("Hello World!");
        i++;
    }

    std::cin.get();

用for还是while，取决于是否需要新变量，

循环前不用声明变量一般用while，因为不用之前声明变量或每次更新值。

do while

该循环至少会被执行一次

控制流语句

• continue

如果还能进行迭代的话，直接进行下一次的迭代；

否则，就会结束循环。

 
    for (int i = 0; i < 5; i++)
    {
        if (i > 2)
            continue;
        Log("Hello World!"); 
        std::cout << i << std::endl;
    }

• break

主要是用在循环里，但也经常出现在switch语句中，直接跳出循环。

  for (int i = 0; i < 5; i++)
    {
        if ((i + 1) % 2 == 0)
            break;
        Log("Hello World!"); 
        std::cout << i << std::endl;
    }

• return

直接完全的退出函数。

只有void是可以直接用return。

指针

一个指针只是一个地址，它是一个整数，存储着一个内存地址。

void基本上是完全没有类型的，

void* ptr = 0; 
void* ptr = NULL; 

&var中的&——你的内存地址是什么

逆向引用指针——读取或写入那个地方的数据

#include <iostream>
#define LOG(x) std::cout << x << std::endl

int main()
{
    int var = 8;
    int* ptr = &var;    
    *ptr = 10;
    LOG(var);
    std::cin.get();
}

#include <iostream>
#define LOG(x) std::cout << x << std::endl

int main()
{
    char* buffer = new char[8];
    memset(buffer, 0, 8);

    delete[] buffer;    //删除
    std::cin.get();
}

char* buffer = new char[8];

char是一个字节；buffer（缓冲缓存的意思）；然后把它设置为大小为8的new char[]

分配了8个字节的内存，并返回一个指向这块内存的开始地址的指针；

memset(buffer, 0, 8);

memset（）函数——用我们指定的数据填充一块内存，它接收一个指针，该指针指向这块内存的开始处

然后接受一个值，比如说0；然后是大小，就是应该填充多少字节，

指针的指针

char** ptr = &buffer;

指针的指针，取名为ptr，并将它设为buffer的内存地址。

引用（指针的扩展）

引用——对现有变量引用的一种方式

与指针不同，指针中要先创建一个指针变量，然后给他赋值nullptr或者其他等于0的值

引用不能这么做，因为“引用”必须引用一个存在的变量，引用本身并不是一个新的变量，它们并不真正占用内存。

#include <iostream>

#define LOG(x) std::cout << x << std::endl

int main()
{
    int a = 5;
    int& ref = a;
    ref = 2;

    LOG(a);

    std::cin.get();
}

int& ref = a;

先是变量类型，紧跟&（&其实是变量声明的一部分）

void  Increment(int value)        //输入整数递增
{
    value++;
}

int main()
{
    int a = 5;
    Increment(a);

    LOG(a);

    std::cin.get();
}

Increment(a)，递增的是新建的value这个变量，a本身没有变化

我们可以在函数里找到这个变量地址，看到数字5，然后加以更改，通过内存地址完成写入，因为我们把内存地址传进了函数

Increment(&a);

把函数的形参变为一个指针，在调用函数的时候将a的内存地址而不是a本身传递给函数

(*value)++;

逆向引用从而改变地址存储的数值，而不是地址本身

逆向引用指针——读取或写入那个地方的数据

指针就是地址，实质是一个整数，如果直接在它后面++而不在前面带*，它就会增加内存地址本身而不是实际的数值。

操作符的优先级。递增符号会优先执行，所以加一个括号保证先逆向引用，再递增那个地址的数值。

#include <iostream>

#define LOG(x) std::cout << x << std::endl

void  Increment(int* value)        //输入整数递增
{
    (*value)++;
}

int main()
{
    int a = 5;
    Increment(&a);

    LOG(a);

    std::cin.get();
}

类

由类类型制成的变量叫做对象，新创建对象的过程叫做实例化。

Player player;    //创建了一个类型为Player的player对象
player.x = 5;    //成员访问运算符player.    变量名称x

访问控制

当初创建一个类时，你可以指定类中属性的可见性，默认情况下，类中成员的访问都是私有的，意味着只有类内部的函数才能访问这些变量，但是我们希望从main函数访问这些变量

class Player
{
public:
    int x, y;
    int speed;
}

public表示我们可以在类外的任何地方去访问这些变量

class Player
{
public:
    int x, y;
    int speed;
    void Move(int xa, int ya)
    {
        x += xa * speed;
        y += ya * speed;
    }
}

类内的函数称作method