c++学习笔记：运算符、指针

传入数组名，就是传入数组的首地址
c++运算
“=”赋值；“==”相等；
%
取模运算符：9/3=1；不能用于小数类型；
++
前置：递增先变量+1，然后表达式运算；后置：先进行表达式运算，后让变量+1；
int a = 10;
int b = a++ 乘10;
cout << a << endl << b << endl;
输出结果为11;100;
"b是a乘10；然后a自增为11；

比较运算符
cout<<(a==b)<<endl;

逻辑运算符
！非：真假互换；&&与：都真才为真；|| 或：一真就为真；

If语句
if()
{
/if()//嵌套
/{
/}
/ else if()
/ {
/ }
//else
//{
//}
}
else if()
{
}
else
{
}

三目运算符
（a>b?a:b)

switch
只能是整型或者字符型，不可以是区间
switch(a)
{
case 0:
break;
case 1:
break;
default:
break;
}

while()
也可以用break跳出循环

随机值：
#include<ctime
rand()%100: 0-99随机值；
int main()
{
srand(unsigned int)time(NULL));
}

for
for(int i=0;i<10;i++)
{
}
int arr[2][3];
int arr[2][3]=
{
{1,1,1},
{2,2,2}
};

**(int)&arr[0][0];**获取第一行第一列的地址：加“&”

函数的调用
int test01(int a, int b)
{
int sum = a + b;
return sum;
}
void test02(int arrt[])//直接数组
{
cout << arrt[0] << endl;
}

int main()
{
int a, b;
cin >> a >> b;
int c=test01(a, b);
cout << c << endl;
int arr[]={1,2};
test02(arr);

return 0;

}

形参与实参
值传递

函数
函数的声明可以有多次，但是函数的定义只能有一次；

指针
访问地址；通过地址直接改变变量；指针就是一个地址；32操作系统占用4个字节空间；64位占用8个字节；
int a=10;
定义指针：
int *p;
p=&a;
访问指针：解引用；
p;
给指针变量初始化；当不知道指针要指向哪里的时候，就让它为空指针；空指针不能进行访问；
“用指针直接指向一个不是自己申请的内存空间，然后解引用，语法没有问题，但是会运行错误；
const intp=&a;指针指向的值不能改；
int *const p2=&a;指针的指向不能改；

指针数组
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//首地址
p++;//地址偏移，
引用传递
传入数组名，相当于传入数组的首元素的地址；
void swap02(int p, int p2)**
{
int temp = *p;
*p = *p2;
*p2 = temp;
}
int main()
{
int a, b;
cin >> a >> b;
swap02(&a,&b);
cout << a << b;
return 0;
}

把数组传入函数，写入数组名，函数需要运用指针去接受首地址；
冒泡排序、传指针数组
void bubbleSort(int arr,int len)
{
for (int i=0;i<len-1;i++)
{
for (int j=0;j<len-1-i;j++)
{
if (arr[j]<arr[j+1])
{
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
}
void printArray(int arr, int len)
{
for (int i=0;i<len;i++)
{
cout << *arr << " ";
arr++;
}
}
int main()
{
int arr[10] = { 1,3,2,4,5,6,8,7,9,10 };
int len = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, len);
printArray(arr, len);
return 0;
}

结构体代码块外面有“；”而普通函数的实现没有
struct student01
{
string name;
int age;
int score;
};

int main()
{
student01 s1;
student01 s2 = {“李四”,5,80};
s1.age = 4;
s1.name = “张三”;
s1.score = 80;
cout << s1.age << s1.name << s1.score << endl;
cout << s2.age << s2.name << s2.score << endl;
return 0;
}
结构体数组
struct student
{
string name;
int age;
int source;
};
int main()
{
struct student stuArr[3] =
{
{“张三”,4,80},
{“李四”,5,86},
{“赵六”,4,66}
};
for (int i=0;i<3;i++)
{
cout << stuArr[i].name << stuArr[i].age << stuArr[i].source << endl;
}
return 0;
}
结构体指针->
student s1 = { “王五”,10,900 };
student* p = &s1;
cout << p->name << p->age << p->source << endl;
void printStudent(const student *s1)//const 让形参不会修改，并且传指针节省空间
{
cout << s1.name << s1.age << s1.source << endl;
}

清屏代码
system(“cls”)//清屏代码
system(“pause”)//按任意键继续
程序运行之前：分为全局区和代码区
代码区：共享和只读
全局区
静态变量，全局变量，字符串常量，const全局常量
局部变量
写在函数里面的变量：main 函数里面的变量也是局部变量
const修饰局部常量
程序运行之后：栈区、堆区
栈区：编译器释放，函数的参数值，局部变量等，：不要返回局部变量的地址；会被自动释放；
堆区把在堆区创建的地址给你，并不是数据本身返回的是指针；关闭程序后，系统也会帮你释放
int* func()//返回值是地址
{
int* p = new int(10);//局部变量，数据存在堆区，用指针去接受地址；这个指针变量存放在栈区；小括号是一个元素[10]，是包含10个元素的数组
return p;//
}
int main()
{
int* p = func();
cout << *p << endl;
return 0;
}
{
//对于数组而言：p3=p3[0]
int arr[3] = { 1,2,3 };
int p3 = arr;
cout << p3[0] << endl;
cout << p3[1] << endl;
cout << *p3 << endl;
cout << (++p3) << endl;
}
{
int arr = new int[10];
for (int i=0;i<10;i++)
{
arr[i] = i + 100;
}
for (int i=0;i<10;i++)
{
cout << arr[i] << endl;
}
delete[] arr;
}

引用同一块地址，起别名；
int a = 10;
int& b = a;
引用必须初始化，且初始化后不能更改；
引用传递起一个别名，传入；
void mySwap03(int& a, int& b)//以引用的方式接受传入的变量；
{
int temp = a;
a = b;
b = temp;
}
int main()
{
void mySwap03(a)//调用函数，传入a；
}
引用做函数的返回值
必须引用一块合法的内存空间；不能引用“10”之类的数字；
不要返回局部变量的引用；
int& test01()//以下这是错误的；
{
int a = 10;
return a;
}//以上错误
函数的调用可以作为左值；
int& test01()
{
int a = 10;
return a;
}
int& test02()//函数的返回值是引用，这个函数可以作为左值；但是不要返回局部变量
{
static int a = 10;
return a;
}
int main()
{
int& ref = test01();
cout << ref << endl;//10
cout << ref << endl;//乱码
int& ref2 = test02();
cout << ref2 << endl;//10
cout << ref2 << endl; //10
test02() = 1000;
cout << ref2 << endl;//1000
cout << ref2 << endl;//1000
return 0;
}

以下引用本质不重要，直接用就好：简化指针；
引用本质就是指针常量
引用一旦初始化，就不可以发生改变；
加const，表示不能修改
void showValue(const int& a)
{
cout << a << endl;
}