C++基础

基础

一、常量

（1）数值常量：

（2）字符常量：

        普通字符常量：用单引号括起来，如'a',以ASCII码的形式存储，可以与整型变量相互赋值，或进行加减运算。

        转义字符常量：

转义字符

字符	意义
’\n'	换行
‘\t'	跳到下一个tab位
'\0'	空字符

        字符串常量：用双撇括号括起来，系统在字符串最后自动加一个'\0'作为字符串结束的标志。

char c;
c='a'; //正确
c="a";//错误，c只能容纳一个字符，双撇括号内有两个字符

（3）符号常量：用符号名代表一个常量，预编译时把所有符号常量替换为指定的字符串。

#define PRICE 30  //不是语句，末尾不要加分号

二、变量

先定义后使用。允许在定义变量时，对他赋初值，初值可以是常量，也可以是一个有确定值的表达式。

数据类型  变量名列表；

常变量：定义变量时加const关键字，变量在程序运行期间值不可改变，在定义常变量时必须对他初始化。

const int a =3;
float a,b,c,d,e;
float a,b=5.78*3,c=2*sin(2.0);

三、运算符

复合运算符：在赋值符“=”之前加上其他运算符。

a+=3;  //a=a+3;
x*=y+8; //x=x*(y+8)
x%=3;   //x=x%3   取余

优先级：位置在上的优先级高于位置在下，同一行的优先级取决于在表达式中的位置（由左至右）

逻辑运算符	NOT
算数运算符	*,/,%
算数运算符	+,-
关系运算符	>,<,<=,>=
关系运算符	==.!=
逻辑运算符	AND
逻辑运算符	OR
赋值运算符	==

四、选择

1.if

if(表达式1)
    语句1;
else if(表达式2)
    语句2；
else
    语句n;
//当表达式1满足，则不再执行else_if语句

2.switch

• switch语句中表达式，只能是整型或是字符型；
• 当被测试的变量等于case中的常量时，case后跟的语句将被执行，直到遇到break语句为止；当遇到break语句时，switch终止，跳转到switch语句后的下一行。
• 不是每一个case都需要包含break，如果case语句不包含break，会继续后续的case,直到遇到break为止。
• 一个switch语句可以有一个可选的default case，出现在switch的结尾。default case可用于在上面所有case都不为真时执行一个任务，default case中的break语句时不需要的。

switch(表达式)
{
case  常量表达式1：
      语句1；
      break;
case  常量表达式2：
      语句2；
      break;
default：
      语句n;
}

五、循环

1.while

当条件表达式非0时，执行while语句中的循环体。

while(条件表达式）
 {循环体}

2.do-while

先执行一次循环体，然后判别表达之为非0时，返回重新执行循环体，直到表达式值为0。

do
{循环体}
while(表达式）

3.for

for(循环变量赋初值；循环终止条件；循环变量增值）
{
    语句;
}

4.break;continue

break;//结束整个循环；
continue;//进入下一次循环。

fro循环新用法

1、拷贝range的元素时，使用for(auto x : range).

2、修改range的元素时，使用for(auto & x : range).

3、只读range的元素时，使用for(const auto & x : range).

5.循环的嵌套

（1）嵌套for跳出内循环

for(int i=0;i<10;i++)
{
    for(int j=0;j<3;j++)
    {    
        if((i+j)==3)
        {
            break;//如果i+j=3，跳出内循环，再次执行第一重循环
        }

    }
}

（2）跳出while循环

while(true)
{
    if(num==10)
    {
        break; //如果num==10，跳出while循环
    }

}

六、数组

1.一维数组

存放在一块连续的内存空间，每个元素都是相同的数据类型，通过下标访问数组元素（数组的下标是从0开始）

数据类型 数组名[数组长度]；

数据类型 数组名[数组长度]={值1，值2，...}；

//定义
int arr1[5];
int arr2[5]={1,2,3,4,5};
//赋值
for (int i=0;i<sizeof(arr1)/sizeof(int);i++)
{
  arr1[i]=i;
}

数组名作用：

    可以和获取数组在内存中的首地址；

arr1;//数组的首地址
&arr1[0];//数组第一个元素的地址

    可以统计整个数组在内存中的长度；

sizeof(arr1);

2.二维数组

数据类型 数组名[行数][列数]；

数据类型 数组名[行数][列数]={{数据1，数据2}，{数据3，数据4}}；

数据类型 数组名[行数][列数]={数据1，数据2，数据3，数据4}；

数据类型 数组名[][列数]={数据1，数据2，数据3，数据4}；

用new申请一块内存空间存放二维数组：

#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    int n=10,m=2;    
    int **swp;      //动态申请二维数组 n行 m列
    swp=new int*[n];
    for(int i=0;i<n;i++)
    swp[i]=new int[m];
    return 0;
}

七、指针

指针是用来存放变量地址的。用&获取变量地址对指针进行赋值。

基类型  *指针变量名称；

/*基类型：指针指向的变量类型*/

1.指向变量

int *p;//指针p指向int类型
int* *p;//指针p指向int*类型

int a=10;
int *q;
int **p;
q=&a; //q指向a
p=&q; //p指向q,q是一个Int类型指针

2.指向数组

数组名代表数组中第一个元素的地址。使用指针指向数组。

int a[10];
int *p
p=a;
p[i]与*(p+i)等价

3.指向函数

使用指针指向函数。

函数类型   (*变量名)   (函数列表);

int max(int x,int y);  //定义函数
int (*p)(int,int); //定义函数指针p
p=max;  //指针p指向max函数，即将max函数的入口地址赋值给指针变量p
m=p(a,b); //通过指针调用函数  m=max(a,b)作用相同

4.指针数组 

数组中的每一个元素都是指针。

类型名 *数组名[数组长度]

int *p[4]={地址1，地址2，地址3，地址4};  //p[4]存放了四个int数据的地址
vector<int> *pv=0;  //指向vector<int>的指针
vector<int> *p[4]={地址1，地址2，地址3，地址4}；//p[4]存放了4个vector<int>的地址

5.指向结构体

访问结构体变量的2种方式：

结构体变量.成员名；(*p).成员名；    //stu.name=(*p).name
p->成员名；    //p->name

Student stu1;  //实例化结构体
Student *p=&stu1; //将结构体变量stu的起始地址赋值给指针变量p

6.指向对象

类名 *对象指针名

class_name *ptr=new class_name(value); //初始化对象
/*
class_name:类名
value：类型为type_name
*/
class_name (type_name); //构造函数
delete ptr; //析构

eg.

Time *pt;  //定义pt为指向Time类对象的指针
Time t1;  //实例化类
pt=&t1;//指向
pt->hour; //访问类t1中的成员hour;(*pt).hour;
pt->get_time();//访问类t1中的成员函数get_time();

7.new/delete

new 类型[初值]

delete 指针变量; //变量
delete []指针变量;//数组

 new分配数组空间时不能指定初值。当无法分配空间，new会返回一个空指针NULL；new在堆上开辟了空间，new出来的是一段空间的首地址，需要用指针来存放这段地址。

int *P = new int(100);   //开辟存放整数的空间，指定初值为100，返回指向该空间的地址
int *pt= new int[5][4];   //开辟一个存放二维整形数组的空间，返回首元素的地址

//eg.不定义结构体变量，通过指针直接访问
Student *p; //定义指向结构体类型Student的数据的指针变量p
p=new Student;  //new一个存放Student型数据的空间，把地址给p
p->name="tian";  //通过指针直接向结构体变量赋值
delete p;    //撤销该空间

//eg.分配动态数组
int *p = new int[20]; //创建20个元素的数组
p[0]=1;  //删除变量
delete[] p;  //删除数组

//创建二维数组：
int  **p=new int *[row]
for(int i=0;i<row;i++)
{
 p[i]=new int[line];
}

int (*p)[line]=new int [row][line];

main函数

int main(int argc,char *argc[])
/*
    在执行程序时带参数运行
    argc: int类型，代表第二个参数（程序启动时带的参数）的个数,自动生成。
    argv: 指针数组，每一个元素时一个字符指针，argc[0]默认执行文件的路径，不用带这个参数，从argv[1]开始；读取传入的参数也是从argv[1]开始读
*/

eg.

#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    int i;
    cout << "当前文件的路径：" << argv[0] << endl;
    for (i = 1; i < argc; i++)
    {
        cout << i << "," << argv[i] << endl;
    }
    system("pause");
    return 0;
}

new

int *ptr=new int

上面语句实现了3个功能：取一块内存空间、调用构造函数、返回正确的指针。

• 删除单变量地址空间

int *a=new int;
delect a;

•  删除数组空间

int *a=new int[5];
delect [] a;

•  复杂类型

MyClass *mc =new MyClass[5];
delect[] mc; 

分配了5个连续的MyClass实例，并依次调用了构造函数，delect[]针对动态分配得到的每个对象调用析构函数，然后再释放内存。