C++学习笔记

1变量和数据类型

变量是计算机内存的一块特定的空间，由一个或多个连续的字节组成。

8 bit（比特）= 1 byte（字节）

bps（bit per second）10M 50M等换成字节数除以8

变量命名：字母数字下划线组成；第一个字符为字母或下划线；不能有其他特殊字符；不能使用保留字。

常用数据类型：整型 int 32位，短整型 short int 16位，长整型 long int 32位，单精度浮点型 float 32位，双精度浮点型 double 64位，字符型char 8位。

float：32位，4字节，取值范围-3.4E+38~+3.4E+38 ，6-7位有效数字 ，例如float a = 98.5f

double：64位，8个字节，取值范围-1.7E+308~+1.7E+308，15位有效数字，例如 double value = 98.5；

默认小数位double类型；

强制以小数的方式显示： cout<<filxed;

控制输出的精度：#include <iomanip>

cout<<setprecision(2);

类型的最大值，INT_MAX；LONG_MAX ；INT_MIN等

 const int N = 20;

常量非变量const ;

sizeof()测量数据类型的长度，字节为单位，例如long double为12个字节；long double适合更精确的数据；

sizeof(3.14)=8,sizeof(3.14f)=4

先定义为long double再做运算精度更高，比long double a = 10.0/7.0精度高

long double longdouble_a =10.0;
long double longdouble_b = longdouble_a(10.0)/7.0;

 2.第二章

设置控制台的标题

#include<window.h>

在主函数中

SetConsoleTitle("哈哈哈");

在变量定义上面一行用

/**a的值*/       这样的注释可以描述变量，一个/ 两个星号开头

char 八位 一个字节  范围 -128~127

uchar  范围0-255

几进制没有几，n进制没有n

大写和小写之间差一个空格32

(char)('A'+' ')为'a'

'A'+' '为97

cin>>a;

a=cin.get();

'a' 蜂鸣器

字符串 string a = "哈哈哈"

setw(8)设置字符宽度 ,默认右对齐  #include<iomanip>

cout<<setw(8)<<123<<setw(8)<<456<<endl;

设置左对齐

cout<<left;
cout<<setw(8)<<123<<setw(8)<<456<<endl;

设置字符填充;默认空格填充

cout<<left;
cout<<setfill('-');
cout<<setw(8)<<123<<setw(8)<<456<<endl;

一元运算符：++、--

二元运算符：+ - * / %

int a;
a=i++;//将i的值赋值给a，即a=i；然后再执行i=i+1；
也就是【a=i++;】与【a=i; i=i+1;】等价。
a=++i;//将i+1的值赋给a,即a=i+1;然后再执行i=i+1；
也就是【a=++i;】与【a=i+1;i=i+1;】等价。

 3.赋值、关系、逻辑运算符

赋值运算符=

复合运算符 += -= /=

关系运算符 ==，>，<，<=，>=，!=

cout << (1<2)<<endl;为1或者0

添加cout<<boolalpha;后变为true false

逻辑运算符 与 或 非 && || !

位运算符

按位非，例如~2

1.二进制取反 八位00000010正数11111101负数

2.负数二进制转换为十进制：将二进制取反，加1，结果为负

原始数+1取相反数

左移右移 运算快，例如2的倍数

sizeof()以字节为单位计算长度。string类型时多加了1，末尾有空字符

一个汉字两个字节

三目运算符 ? :

?前为真取冒号前的，？前为假取冒号后的

条件语句

if (){ } else if {} else if {} else {}

switch(...){

case ... :

  语句;

   break;

case...:}

     default:

    }

    int choice =10;
    switch(choice)
    {
    case 1:
        cout <<1<<endl;
        break;
    case 2:
        cout<<2<<endl;
        break;
    case 3:
        cout<<3<<endl;
        break;
    default:
        cout<<1000<<endl;
        break;
    }

区间范围用if else if esle

4.循环

while

初值、判断、更新

    int i = 0;
    while(i <=10){
        cout << i<<endl;
        i++;
    }

 生成随机数

#include<cstdlib>

int randnum=rand();

调试时：选中 调试>调试窗口>监视。红色按钮开始调试。

 do while

先执行再判断

do {循环} while {循环条件};

while满足时继续do循环

do while至少会执行一次，do

 for 循环

for(a;b;c){语句块}  a 循环变量初始值，b 循环终止条件，c 循环变量的更新

 循环次数确定时，通常用for循环；

循环次数不确定时，通常选用while，do-while循环

数组

连续的内存空间

一维数组 定义 

数据类型 名称[大小];

int N =100;

int num[N];

初始化int num[5]={1,2,3,4,5};

int months[12]={1,3,5,7,8,12};不够个数的默认为0

int days[]={1,2,3};

int days[12]={};

int days[12]{};

取出数组days[i]

计算数组的长度 sizeof(nums)/(sizeof(数组第一个元素或数组类型))

 冒泡排序

依次比较，如果前者大则交换

一共有n个数，第一轮比较n-1次；

    //冒泡排序
    int temp;
    int N=5;
    for(int i=0; i<N-1; i++)
    {
        for (int j=0; j<N-i-1; j++)
        {
            if (nums[j]<nums[j+1])
            {
                temp=nums[j];
                nums[j]=nums[j+1];
                nums[j+1]=temp;
            }
        }
    }

选择排序

从未排序的数组中依次选出最小值放在前面，如此重复

    int nums[5]= {11,22,43,14,25};
    int min=nums[0];
    int minIndex=0;
    int temp1;
    int N=5;
    for (int i=0;i<N-1;i++)
    {
        min=nums[i];
        minIndex=i;
        for(int j=i+1;j<N;j++)
        {
            if(nums[j]<min)
            {
                min=nums[j];
                minIndex=j;
            }
        }
        if (minIndex>i)
        {
         temp1=nums[minIndex];
         nums[minIndex]=nums[i];
         nums[i]=temp1;
        }
    }

 

二维数组

定义同一维数组，初始化

int a[3][2];

double scores[row][col]{1,2,3,4,5,6,7,8,9};
cout <<scores[1][2]<<endl;

向量容器vector

快速动态分配内存的数组

#include <vector>
#include <algorithm>


    vector<double> vec1={1,2,100,4,5};
    vector<int>vec3(20,98);//20个元素，每个都为98
    vec1.push_back(100);

    cout<<vec1.size()<<endl;
    //迭代器遍历
    vector<double>::iterator it;
    //it.begin end
    for (it=vec1.begin();it!=vec1.end();++it){
        cout<<*it<<endl;
    }
    sort(vec1.begin(),vec1.end());
    for (it=vec1.begin();it!=vec1.end();++it){
        cout<<*it<<endl;
    }
    reverse(vec1.begin(),vec1.end());
    for (it=vec1.begin();it!=vec1.end();++it){
        cout<<*it<<endl;
    }

指针

一个值为内存地址的变量（数据对象）

数据类型 *指针变量名;

定义时表示指针类型；使用时表示取值

int char float double

int* p;

int num=1024;

p=&num;

字符型指针是字符串形式存储，

转换为地址(void *)p,void 是任意类型

#include <iostream>

using namespace std;

int main()
{   double num=12;
    cout << "Hello world!" << endl;
    double* p;
    p = & num;
    *p=100;
    cout<<p<<'
'<<*p<<endl;
    cout<<num<<endl;

    char ch='a';
    char *pt_ch=&ch;
    cout<<(void *)pt_ch<<'	'<<*pt_ch<<endl;
    return 0;
}

空指针

不指向任何对象

int *ptr1 = nullptr;

int *ptr2=0;//不能等于其他的数字

不定义的话 会分配默认值，野指针，避免。

没有初值就赋值为空指针；

void*指针

特殊类型指针，可存放任意对象的地址

不能修改变量值；编译不通过

一般用来和其他的指针比较；

引用reference

为对象起了别名

int a=10;

int &a1=a;

引用只能绑定对象，不能和变量值绑定

引用对指针进行了简单封装，底层仍然是指针；

获取引用地址时会进行内部转换；

    int a=10;
    int & a1=a;
    int *p=&a;
    int *p1=&a1;

    cout<<p<<'	'<<p1<<endl;
    a1=20;
    cout<<a<<endl;

指针与数组

指针当数组用，指针占四个字节

    double arr[5]={10,9,8,7,6};
    double *p = arr;
    cout<<p[2]<<endl;

打印p的时候是地址，p[2]打印8

指针++时平移到下一个数组的元素

 数组名是连续内存地址的首地址；因此可以*p=arr，而不是*p=&arr；数组名不能加减。

动态分配内存

使用new分配内存 

在运行阶段分配未命名的内存以及存储值，此时只能通过指针访问内存

int *p = new int;

delete释放内存

 

数组 

运算符&取内存地址，*取内存地址的值

指针不支持加减乘除等，可以++。--，实际是变量存储地址的移动。移动的大小于指针类型有关