基于c的c++学习day1

C到C++ :

C语言面向过程：
自己洗衣服
自己做饭
自己扫地
事情分条目和步骤，一步步来做。符合计算机的思维方式。
执行效率高，开发效率低

C++面向对象：
找个对象让Ta来做
调用不同的对象来处理事物，对象之间相互调用。符合人的思维方式
执行效率稍低，开发效率高

C语言核心是怎么来做
C++核心是让谁来做

C中没有的但是不是面向对象的内容：

1. 引用(重点)

给一个变量或常量取个别名,操作引用就相当于操作变量本身

#include <iostream>
using namespace std;
int main()
{
  int jiNan=90;
  int &quanCheng=jiNan;
  quanCheng+=5;
  //cout是输出  endl:end line 换行
  cout<<quanCheng<<" "<<jiNan<<endl; //95 95
  cout<<&quanCheng<<" "<<&jiNan<<endl; //0x61fe88 0x61fe88
}

引用的本质是指针常量 int * const b=&a;

引用的性质

1.当成为一个变量的引用之后，就不能成为其他变量的引用

#include <iostream>
using namespace std;
int main()
{
  int jiNan=90;
  int qingDao=91;
  int &quanCheng=jiNan;
  //&quanCheng=qingDao;//错误 不能重新赋值
}

2.引用必须有初始值，并且不能为NULL

#include <iostream>
using namespace std;
int main()
{
  int jiNan=90;
  int qingDao=91;
  //int &quanCheng; //错误必须赋值
  //int &quanCheng=NULL;//不能赋值NULL
}

3.如果初始化的内容是纯数字，引用需要定义为常引用。代表引用不可以更改所指向的内容

#include <iostream>
using namespace std;
int main()
{
  //引用是可读可写  100只是可读
  //int &b=100; 错误
    const int & b=100;
    cout<<b<<endl;
}

4.如果引用定义成常引用。就不能直接更改变量的值，但是通过变量可以间接改变引用的值

#include <iostream>
using namespace std;
int main()
{
  int a=100;
  const int & b=a;
  cout<<a<<" "<<b<<endl; //100 100
  //b++; error: increment of read-only reference 'b'
  a++;
  cout<<a<<" "<<b<<endl; //101 101
}

引用的应用
引用作为参数，不需要给参数开辟空间，也没有产生副本。提高了效率

#include <iostream>
using namespace std;
void test(int a,int b){
   int t=a;
   a=b;
   b=t;
}
void test2(int * a,int * b){
  int t=*a;
  *a=*b;
  *b=t;
}
void test3(int & n,int & m){
    int t;
    t=n;
    n=m;
    m=t;
}
int main()
{
    int n=10;
    int m=20;
    test2(&n,&m);
    cout<<n<<" "<<m<<endl; //20 10
    test3(n,m);
    cout<<n<<" "<<m<<endl;  //10 20
}

2.c++赋值

c++可以像下面这样赋值

#include <iostream>
using namespace std;
int main()
{
    int a=100;
    int b(200); //c++赋值
    cout<<a<<" "<<b<<endl; //100 200
    double c=3.14;
    int d(c); //强制转化 
    cout<<d<<endl; //3
}

键盘输入：
cin输入 ,cout输出
iostream中 i代表input o代表output

#include <iostream>
using namespace std;
int main()
{
  int a;
  cin>>a;
  cout<<"输入的值是"<<a;
}

3.string类型 字符串（掌握）

字符串类型不是基本的数据类型，而是c++中的一个类，内部有很多方法，方便处理字符串内容.

#include <iostream>
using namespace std;
int main()
{
    string s="123456";
    cout<<s[0]<<endl;
    cout<<s[6]<<endl; //效率高,超出数组范围不会报错,易出错
    //cout<<s.at(6)<<endl;//更安全 会报超出范围错误
    cout<<s<<endl;
    cout<<"字符串长度"<<s.length()<<endl; //6
    //for循环遍历
    for(int i=0;i<s.length();i++){
        cout<<s[i]<<" ";
    }
    cout<<endl;
    //for each方式遍历
    cout<<"用for each方式取"<<endl;
    //字符串中每个元素是char类型的。
    //string 对应字符数组 字符数组每一个元素是char
    for(char c:s){
        cout<<c<<" ";
    }
}

at方式取元素 更安全 ,用[]的方式效率高

4.内联函数 (掌握)

些函数代码量比较少（5行以内），运行时间比较短，如果调用的次数比较多，就需要考虑调用函数所花费的时间。用内联函数处理这样的问题。
在定义上加上inline关键字，在编译时自动展开到主函数中。

#include <iostream>
using namespace std;
void show(); //声明
inline void show(){ //定义
  cout<<"内联函数";
}
int main()
{
  show();
}

5.函数重载 （重点）

函数可以重名，根据参数的个数，参数的类型不同来区分具体调用哪个函数，不能以返回值来区分；省去解决相似问题，取名字花费时间，提高效率。
根据参数类型不同选取不同的函数
参数个数不同：

#include <iostream>
using namespace std;
//普通文员 销售 开发。。。
//参数个数不同选取不同的函数
void salary(int jiBen){
  cout<<"文员工资"<<jiBen<<endl;
}
void salary(int jiBen,int jiangJin){
  int total=jiBen+jiangJin;
  cout<<"销售工资"<<total;
}
int main()
{
    salary(2000);
    salary(2000,4000);
}

参数类型不同：

#include <iostream>
using namespace std;
void show(int a){
    cout<<"int:"<<a<<endl;
}
void show(string s){
    cout<<"string:"<<s<<endl;
}

int main()
{
    //根据参数类型不同选取不同的函数
    int n=100;
    show(n);
    string s="hello";
    show(s);
}

6.函数的默认值（掌握）

1.当有参数默认值的函数被调用的时候，如果不传参，就会选取默认值，否则就改成传入的数据。

#include <iostream>
using namespace std;
void draw(string color="黑色"){
  cout<<color<<endl;
}
int main()
{
    draw();
    draw("红色");
}

2.声明和定义只能一个位置加默认值

#include <iostream>
using namespace std;
void method(int a=10); //声明处加默认值
void method(int a){
    cout<<a<<endl;
}
int main()
{
    method();
}

3.当有多个参数加默认值时，”向后原则”,中间有一个参数有默认值，其后的参数都需要加默认值

#include <iostream>
using namespace std;
void method(int a=10); //声明处加默认值
void method(int a){
    cout<<a<<endl;
}
//定义加默认值 b加了默认值 c也必须加默认值
void method2(int a,int b=20,int c=40){ 
    cout<<a<<" "<<b<<" "<<c;
}

int main()
{
    method2(10,30);
}

4.函数重载不要和默认值一块用 可能会产生二义性，产生错误，编译器无法做出选择

#include <iostream>
using namespace std;
void method(int a){
    cout<<a<<endl;
}
void method(int a,int b=10){
    cout<<a<<endl;
    cout<<b<<endl;
}

int main()
{
    //method(20); 错误
}

哑元函数（熟悉）
参数只有类型，但是没有名字。这个参数就成为哑元，这样的函数成为哑元函数.
后续的运算符重载会用到

#include <iostream>
using namespace std;
void method(int){
    cout<<"hello"<<endl;
}
int main()
{
    method(20);
}

面向对象基础

1.类与对象的概念（重点）

抽象：把一个事物的关键点 提取出来
人可以作为一个对象，一个对象包括属性和行为
人的属性：姓名，性别，年龄 。 又称成员变量
人的行为：吃饭，跑步，学习。 又称成员函数/成员方法
属性：都是名词，用来描述事物是什么样子的
行为：都是动词。用来描述事物能做什么
车
属性：品牌，型号，
行为：载人 运行空调
类就是把对象的属性和行为“捆绑”在一起，作为一个整体。

#include <iostream>
using namespace std;
class Phone{ //类首字母大写
public: //公共权限
    string band;
    string model;
    int price;
    //打电话
    void communicate(){
        cout<<"打电话"<<endl;
    }
    //播放音乐
    void play_music(){
        cout<<"虽然我只是一只羊~"<<endl;
    }
    //玩游戏
    void play_game(){
        cout<<"Timi"<<endl;
    }
};
int main()
{


}

2.实例化对象（重点）

根据类来创建对象实例
1.栈内存对象出了生命周期（所在花括号执行完）自动销毁。
调用 方式通过对象名.调用函数

#include <iostream>
using namespace std;
class Phone{
public: //公共权限
    string brand;
    string model;
    int price;
    //打电话
    void communicate(){
        cout<<"打电话"<<endl;
    }

    //播放音乐
    void play_music(){
        cout<<"虽然我只是一只羊~"<<endl;
    }
    //玩游戏
    void play_game(){
        cout<<"Timi"<<endl;
    }
    void show(){
        cout<<brand<<" "<<model<<" "<<price<<endl;
    }
};
int main()
{
    Phone p;
    p.brand="iphone";
    p.model="14";
    p.price=10000;
    p.show();
    
    Phone * p2=new Ph
}

2.堆内存创建对象
用new关键字创建。delete销毁对象，如果不销毁，会造成内存垃圾。运行卡慢。
delete指向对象的指针

 Phone * p2=new Phone;
    p2->brand="xiaomo";
    p2->model="13";
    p2->price=999;

    p2->show();
    p2->communicate();
    p2->play_music();
    p2->play_game();
    delete p2;
    p2=NULL;