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; }
链接：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); } }
-------
