C++ 复习

int main()
{
    int a = 1;
    int b = a++;
    cout << a << b << endl;
    return 0;
}

输出2  1

#include<iostream>
using namespace std;

int main()
{
    int a = 1;
    int b = ++a;
    cout << a << b << endl;
    return 0;
}

输出2  2

int main()
{
    int a = 1;
    int b = a += 1;
    cout << a << b << endl;
    return 0;
}

输出2  2  

第三种比较好

-----------------------

const 函数不能引用非const函数

————————

VSCODE 小技巧：

1.Selection->Add cursor to line ends

2.选中一段代码 ALT+↑可以移动代码

3.按住ALT可以选中多个字段同时修改

4.按住CTRL可以查看源码

————————

#pragma once

头文件作用：为了避免同一个头文件被包含（include）多次

可以规避一些莫名其妙的错误

————————

const  int& a  //经常这样组合使用

引用可以减少读取次数

 

#include < iostream.h> 
#define SQR(A) A*A
void main() { 
    int x=6,y=3,z=2; 
    x/=SQR(y+z)/SQR(y+z); 
    cout< < x< < endl; 
}

宏替换是直接替换。 

x/=SQR(y+z)/SQR(y+z); 相当于：x/=y+z*y+z/y+z*y+z;

而除等（/=）的优先级低于+、-、*、\。所以先计算/=右边的.而x为int型，结果保留整数位，所以为0，选择D。

————————————

作者：wuxinliulei
链接：https://www.zhihu.com/question/25041590/answer/68781752
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

#include <iostream>

using namespace std;

class a
{
public:
    virtual ~a()
    {
         cout<<"delete a"<<endl;
    };
};

class b : public a
{
   ~b()
   {
       cout<<"delete b"<<endl;
   };
};


int main()
{
    a *pa = new b;
    delete pa;

    return 0;
}

这样会先调用a类的析构函数，再调用b类的析构函数

删除掉a类中的virtual 修饰
这样只会调用a类的析构函数


上面是现象，题主显然问的是原因？

当使用delete pa指向基类的引用时，释放pa所指的内存，而pa所指的是b对象，为什么不会调用b的析构函数呢？这里由于是静态联编，b在编译时已经确定所指向的函数时b的函数，而不会根据对象a来确定指向的函数。如此一来如果b申请的内存资源，但是没有在它的析构函数中释放资源，造成内存泄露。

细想一下，出现虚函数的原因不也是这个吗？

增加了virtual机制，在进行编译的时候，看到virtual就会自动将方法指向b的地址，于是我们就可以通过设置机制找到b的析构函数。

为了改变这个，就出现了虚析构函数

　　只要将基类的析构函数设为virtual型，则所有派生类都自动将析构函数设为virtual型，这样子就保证了不会因为析构函数未被调用而导致内存泄露。

-----

为什么要用基类指针指向派生类对象？

FlyingBird_SXF 2014-11-21 21:29:11 5177 收藏 5
分类专栏： C/C++
版权

        在基类与派生类之间，有一个规定：派生类对象的地址可以赋给指向基类对象的指针变量（简称基类指针），即基类指针也可以指向派生类对象。为什么有这一规定呢？因为它可以实现多态性【1】，即向不同的对象发送同一个消息，不同的对象在接受时会产生不同的行为。

举例说明：

#include <iostream>
using namespace std;
class Shape {
public:
virtual double area() const = 0; //纯虚函数
};
class Square : public Shape {
double size;
public:
Square(double s) {
size = s;
}
virtual double area() const {
return size * size;
}
};

class Circle : public Shape {
double radius;
public:
Circle(double r) {
radius = r;
}
virtual double area() const {
return 3.14159 * radius * radius;
}
};
int main()
{
Shape* array[2]; //定义基类指针数组
Square Sq(2.0);
Circle Cir(1.0);
array[0] = &Sq;
array[1] =&Cir;
for (int i = 0; i < 2; i++) /
{
cout << array[i]->area() << endl;
}
return 0;
}

         上面的不同对象Sq,Cir(来自继承同一基类的不同派生类)接受同一消息（求面积，来自基类的成员函数area()）,但是却根据自身情况调用不同的面积公式（执行了不同的行为，它是通过虚函数实现的）。我们可以理解为，继承同一基类的不同派生对象，对来自基类的同一消息执行了不同的行为，这就是多态，它是通过继承和虚函数实现的。而接受同一消息的实现就是基于基类指针。

 [1]: C++支持两种形式的多态性。第一种是编译时的多态性，称为静态联编。第二种是运行时的多态性，也称为动态联编。运行时的多态性是指必须在运行中才可以确定的多态性，是通过继承和虚函数来实现的。
--------------------------

快排：

void quickSort(int s[], int l, int r)
{
    if (l< r)
    {      
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j]>= x) // 从右向左找第一个小于x的数
                j--; 
            if(i < j)
                s[i++] = s[j];
            while(i < j && s[i]< x) // 从左向右找第一个大于等于x的数
                i++; 
            if(i < j)
                s[j--] = s[i];
        }
        s[i] = x;
        quickSort(s, l, i - 1); // 递归调用
        quickSort(s, i + 1, r);
    }
}

-------