c++入门（下）

//宏函数实际上就是直接替换，宏函数书是不需要建立栈帧的，也就是可以直接展开的，所以宏函数的代码比较短，也相对复杂
/
#define Add(int x,int y) ((x)+(y))  //仅仅是x+y就需要这样书写，相对下面Add代码比较复杂
int Add(int x,int y){
    return x+y;//宏函数本身就是为了节约空间才选择的宏函数
}
int main()
{
    for(int i=0;i<100000;i++){
        Add(i,i+1);//重复多次调用同一函数，我们就直接定义了宏函数来解决
    }
    return 0;
}
//但是由于不能调试，等等缺点，我们C++中出现了内联函数 inline关键字

inline int Add(int x,int y){
    return x+y;
}
//inline的使用，只需要在Add函数之前加上关键字inline即可使得Add函数为内敛函数

//加入说，我们在main函数中或者是一个程序中有10000个地方需要使用Add函数  Add函数的编译后得到的汇编代码比如是50行，那么对于下面函数分析，只看Add函数这一部分，在整个程序中所需的汇编代码有多少行
//内联函数inline
inline int Add(int x,int y){
    return x+y;
}
//如果是内联函数，由于我们不建立栈帧，也就是说，直接展开的方式使用Add函数，所以总汇编代码行数应该为：10000*50行
//使用正常的函数    
int Add(int x,int y){
    return x+y;
}
//在汇编代码中会调用这个函数 call  Add.... 这样的话汇编代码行数为  10000+50

inline int Add(int x,int y){
    cout<<"111111"<<endl;
    cout<<"111111"<<endl;
    cout<<"111111"<<endl;
    cout<<"111111"<<endl;
    cout<<"111111"<<endl;
    cout<<"111111"<<endl;
    cout<<"111111"<<endl;
    cout<<"111111"<<endl;
    return x+y;//这种情况就不会判定为inline内联函数
}

void ac(int) {
  cout << "int" << endl;
}
void ac(int*) {
  cout << "int*" << endl;
}
int main()
{ 
  ac(0);
  ac(NULL);
  ac(nullptr);
  return 0;
}

//类型& 引用变量名(对象名) = 引用实体； 这是引用的适用格式
int main()
{
    int a = 10;
    int& b = a;//给a一个引用，称为b，也就是说，ab都是指向同一个空间，数值为10，
    cout<<b<<" "<<a<<endl;//10 10
    b++;//引用类似于指针，当b数值变的时候，会直接影响到a
    cout<<b<<" "<<a<<endl;// 11 11
    return 0;
}

int main()
{
  int a = 10;
  int& b = a;
  int& c = a;
  int d = 20;
  c = d;//再次引用的时候，实际上不是引用，只是将d的数值赋值给c，进而改变了abc的数值都为d：20 
    //所以C还是a从别名
  cout << a << " " << b << " " << c << endl;
  return 0;
}

int add(){
    static int n=0;
    n++;
    return n;
}
int main()
{
    int ac=add();//这样ac数值为1
    return 0;
}

int add(){
    int n=0;
    n++;
    return n;
}
int main()
{
    int ac=add();//这样ac数值为1
    return 0;
}

int& add() {
  static int n = 0;//静态变量，存放在静态区，所以最后传出来的是静态区的n
  n++;
  return n;//所以返回的数值为1  返回给main函数的ans变量，过程为：用n的别名给了ans
}
int main()
{
  //rand();
  int ans = add();
  cout << ans << endl;//输出结果为1
  return 0;
}
//接下来对比一下没有static的临时变量
int& add() {
  int n = 0;
  n++;
  return n;
}//那么就是  ans得到的也是n的空间，当栈帧没有被破坏的时候输出的是1（正确）如果栈帧被破坏，就输出随机值
int main()
{
  //rand();
  int ans = add();//返回的也是n的别名，但是n的变量所在空间已经摧毁，所以n可以为1，或者为随机值
  cout << ans << endl;//输出的结果可能为1（栈帧没有被破坏），或者是随机值
  return 0;
}

int& add(int x) {
  int n = x;
  n++;
  return n;
}//那么就是  ans得到的也是n的空间，当栈帧没有被破坏的时候输出的是1（正确）如果栈帧被破坏，就输出随机值
int main()
{
  //rand();
  int& ans = add(10);
  cout << ans << endl;
  add(20);
  cout << ans << endl;
  return 0;
}

int& add(int x) {
  int n = x;
  n++;
  cout << &n << endl;
  return n;
}//那么就是  ans得到的也是n的空间，当栈帧没有被破坏的时候输出的是1（正确）如果栈帧被破坏，就输出随机值
int main()
{
  //rand();
  int& ans = add(10);
  cout << &ans << endl;
  add(20);
  cout << &ans << endl;
  return 0;
}

//正确用法
int main()
{
    int x=0;
    int& y=x;
    const int& z=y;//可以const 放小权限  这个是正确的用法
  //如果说我们改变y或者x的数值，z会不会随之变化呢？
    //如图1所示：
    y++;
    return 0;
}
//正确用例 (权限问题)
int main()
{
    double a=10.1;
    int b=a;
    const int& c=a;//输出结果为10.1 10 10 这是权限的缩小
    return 0;
}
//错误用例
int func()
{
  static int x = 0;
  return x;
}
int main()
{
  int& r = func();//初始化int不能赋值给int&类型（报错），实际上就是权限被放大，因为返回的是临时变量，临时变量返回是一个常量，所以应该是用const来接收
    //应该修正为
    const int& r=func();
  return 0;
}

//错误样例：
int& add(int x)
{
    int n=x;  //这是一个临时变量n，返回的时，可能会出现随机值这样的情况
    n++;
    return n;
}
//正确样例：
int& add(int x)
{
    static int n=x; //这是一个静态变量n，返回时，是从静态区中进行引用返回
    n++;
    return n;
}

int& add(int x) {
  static int n = x;
  return n;
}
int main() {
  int& ans = add(10);//ans得到的是n的别名，ans也是引用，我们紧接着调用add函数add(20)，然后进行将50赋值给这个函数。
  add(20) = 50;
//为什么可以赋值？
    //实际上，add函数是引用传参返回，这样我们当然可以将数值再次赋值给这个函数
  cout << ans << endl;//ans的地址和add引用传参返回地址相同，输出数值为50
  return 0;
}

#include<iostream>
#include<vector>
using namespace std;
int main()
{
  int a = 10;
  auto c = a;
  //auto可以用作增强for循环使用，类似于Java中的Object
  //c++ 中的可以识别变量类型的关键字
  //typeid().name();
  int arr[] = { 1,241,54,152,12,12,1 };
  vector <int >v;
  v.push_back(1);
  v.push_back(2);
  v.push_back(3);
  v.push_back(4);
  v.push_back(5);
  for (auto i : arr) {
  cout << i << endl;
  }
  auto d = &a;
  cout << typeid(c).name() << endl;
  cout << typeid(d).name() << endl;
  return 0;
}