一.C++统一初始化: 初始化列表 解决方案
例1：
int main()
{
int a = 10;
int b = 10;
int c{ 10 };//初始化列表
int arr[10] = { 1,2,4,5,6 };
int brr[10]{ 1,2,3,4,5,6 };
int crr[]{ 1,2,3,4,5 };
int drr[] = { 1,2,3,4,5 };
int* ip = NULL;
int* is{ NULL };
return 0;
}
例1：
int main()
{
int a = 12.23;//a=12
//int b{12.23}//类型错误
double dx{ 12.23 };
}
二.输入输出：
1.C 语言输入输出
#include<stdio.h>
int main()
{
int a = 10;
int b(10);
int c{10};
int arr[10] ={1,2,3,4,5,6,7,8,9,10};
int brr[10]{1,2,3,4,5,6,7,8,9,10};
scanf("%d %c",&a,&c);
printf("a = %d ch = %c n",a,c);
return 0;
}
scanf不安全的原因：内存访问越界
解决方法：
(1):加一个宏
#define_CRT_SECURE_NO_WARNINGS
(2):scanf_s:例如：
scanf_s("%10s %8s", string1, 11, string2, 9);
//string1可接受10个字符\0占一个空间
2.C++ 语言输入输出
// cin input 输入流对象 , 键盘
// cout output 输出流对象 ， 控制台(屏幕)
// >> 提取符
// << 插入符
// endl => '\n'; 换行符
#include<iostream>
using namespace std;
int main()
{
char ch;
int a;
double dx;
char str[20];
cin >> ch >> a >> dx >> str;
cout << ch << "\t" << a << "\t" << dx << "\t" << str << endl;
//scanf_s(" % c % d % lf %s", &ch, &a, &dx, &str);//很麻烦类型，取地址符
return 0;
}
//错误的使用方法
{
//cin>>a,ch;
//cout<<a,ch;
}
总结： 使用cout标准输出(控制台)和cin标
准输入(键盘)时，必须包含< iostream >头文件以及std标准命名 空间。endl 相当于 ' n';
#include<iostream>
using namespace std;
int main()
{
const int n = 128;
char str[n];
cin >> str; // 输入 yhp hello this
cout << str << endl; // yhp
cin.getline(str, n); // yhp hello this
cout << str << endl; // yhp hello this
cin.getline(str, n, '#'); // yhp this # go to
cout << str << endl; // yhp this;
return 0;
}
三.const与指针
1.C语言中的const
int main()
{
const int n = 10;//n以变量为主
int arr[n]{ 1,2,3 };//会出现报错，因为数组大小为常量
const int a = 10;//a仍然是变量，值可能还会被改
int b = 0;
int* ip = (int*)&a;
*ip = 100;//a=100
b = a;//b=100
printf(" % d % d % d", a, b, *ip);//100 100 100
return 0;
}
2.C++中的const
int main()
{
//C++，a以常量为主
const int a = 10;//a变成常量,看见a就替换成10
int b = 0;
int* ip = (int*)&a;
*ip = 100;//a=10
b = a;//b=10
printf(" % d % d % d", a, b, *ip);//10 10 100
return 0;
}
3.const 与指针的关系
int main()
{
int a = 10, b = 10;
int* p1 = &a; // 普通指针
const int* p2 = &a; // 指向为常性（解引用为常性)
int const* p2 = &a;
int* const p3 = &a; // 指针变量自身为常性
const int* const p4 = &a; // 指向（解引用）和指针变量自身都为常性
}
int main()
{
int a = 0;
int* p1 = &a; // ok;
const int* p2 = &a; // ok;
int* const p3 = &a; // ok;
const int* const p4 = &a; // ok;
return 0;
}
//编译方式不同
4.常变量与指针
int main()
{
const int a = 10;
int* p1 = &a; // error;
const int* p2 = &a; // ok;
int* const p3 = &a; // error;
const int* const* p4 = &a; // ok;
int* p5 = (int*)&a; // ok 不安全
return 0;
}
5.同类型指针的赋值兼容规程
int main()
{
int a = 10, b = 20;
int* p = &a;
int* s1 = p; // ok;
const int* s2 = p; // ok;
int* const s3 = p; // ok;
const int* const s4 = p; //ok;
}
6.常见的例题
（1）
int main()
{
int a = 10, b = 20;
int* p1 = &a;
*p1 = 100;
p1 = &b;
const int* p2 = &a;
*p2 = 100;//错，*p2被const修饰，不能改变
p2 = &b;
int* const p3 = &a;
*p3 = 100;
p3 = &a;//错p3被const修饰，不能改变
const int* const p4 = &a;
*p4 = 100;//错
p4 = &b;//错
//都被const修饰，都不能改变
}
（2）
int main()
{
//全部编译通过
int a = 10, b = 20;
int* p = &a;//p是a的地址
int* s1 = p;//指针s1=指针p,是a的地址
const int* s2 = p;//指针s2=指针p,是a的地址，并且*s2也就是a不能改变
int* const s3 = p;//指针s3=指针p,是a的地址，并且s3也就是a的地址不能被改变
const int* const s4 = p;//指针s4=指针p,是a的地址，并且*s4也就是a不能改变且也S4就是a的地址不能被改变
return 0;
}
（3）
int main()
{
int a = 10, b = 20;
const int* p = &a;//*p不能被改变，
int* s1 = p;//error//因为*S1的改变会改变p的值，（p指向a的地址）不安全
const int* s2 = p;
int* const s3 = p;//error//因为*S3的改变会改变p的值，（p指向a的地址）不安全
const int* const s4 = p;
return 0;
}
（4）
int main()
{
//全部编译通过
int a = 10, b = 20;
int* const p = &a;
int* s1 = p;
const int* s2 = p;
int* const s3 = p;
const int* const s4 = p;
return 0;
}
总结： 能力强的指针赋值给能力收缩的指针
