C++基础之初始化、输入输出安全问题及常量问题

一.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;
}

总结： 能力强的指针赋值给能力收缩的指针