C++ 知识点

目录

cin

C++输入含空格的字符串  getline()（包含头文件#include ）

const修饰符

auto 

内联函数

带有默认参数值的函数

作用域标识符"::"

new、delete运算符

引用

指针数组和数组指针

string类

---

cin

在默认情况下，运算符“>>”将跳过空白符，然后读入后面与变量类型相对应的值。因此，给一组变量输入值时可用空格符、回车符 将输入的数据间隔开。

当输入字符串（即类型为string的变量）时，提取运算符“>>”的作用是跳过空白字符，读入后面的非空白字符，直到遇到另一个空白字符为止，并在串尾放一个字符串结束标志‘\0’。

C++输入含空格的字符串  getline()（包含头文件#include <string>）

int main()

        {
                 string st;

                 getline(cin, st);

                 cout << st << endl;

                 return 0;

        }

const修饰符

const int a=3;

const与指针

指向常量的指针——一个指向常量的指针变量     底层const

const char* pc = "abcd";
 不允许改变指针所指的变量，即pc[3] = 'x' 是错误的，但是，由于pc是一个指向常量的普通指针变量，因此可以改变pc所指的地址，例如pc = "ervfs";该语句给了指针另一个字符串的地址，改变了pc的值。

常指针——将指针变量所指的地址声明为常量      顶层const

char* const pc = "abcd"；

创建一个常指针，一个不能移动的固定指针，可更改内容，如 pc[3] = 'x' 但不能改变地址，如 pc = ‘'dsff’' 不合法

指向常量的常指针——这个指针所指的地址不能改变，它所指向的地址中的内容也不能改变。

const char* const pc = "abcd"

注：

1. 常量一旦被建立，在程序的任何地方都不能再更改。

2. 与#define不同，const定义的常量可以有自己的数据类型。

3. 函数参数也可以用const说明，用于保证实参在该函数内不被改动

auto 

 1.auto自动类型推断

用于从初始化表达式中推断出变量的数据类型    auto a=10;

auto忽略顶层const

2.auto用于基于范围的for循环

  for (auto x : NumberA[0])
    {
        cout << x <<endl;
    }

在上面的基于范围的for循环中，在x的定义之后，跟一个冒号，之后直接写上需要遍历的表达式，for循环将自动以表达式返回的容器为范围进行迭代        

如果需要在遍历时修改容器中的值，则需要使用引用

for ( auto& n : arr){
     cout<< n++ << endl;
 }

内联函数

在函数名前加关键字inline，该函数就被声明为内联函数。每当程序中出现对该函数的调用时，C++编译器使用函数体中的代码插入到调用该函数的语句之处，同时使用实参代替形参，以便在程序运行时不再进行函数调用。引入内联函数主要是为了消除调用函数时的系统开销，以提高运行速度。

适用于执行快，定义短的函数

带有默认参数值的函数

当进行函数调用时，编译器按从左到右的顺序将实参与形参结合，若未指定足够的实参，则编译器按顺序用函数原型中的默认值来补足所缺少的实参。

void init(int x = 5, int y = 10);
init (100, 19);   // 100 ， 19
init(25);         // 25, 10
init();           // 5， 10

作用域标识符"::"

int value;   //定义全局变量value

int main() 
{
	int value;  //定义局部变量value
	value = 100;
	::value = 1000;
	cout << "local value : " << value << endl;
	cout << "global value : " << ::value << endl;
	return 0;
}

new、delete运算符

*指针可以初始化为变量的地址*

*但更重要的用法是：在运行阶段分配未命名的内存以存储值(只有指针能访问)*

	int* p = new int;		//new找到正确的内存长度，并返回它的地址，程序员把这个地址赋给一个指针

	*p = 520;
	cout << "p指向的值是" << *p << endl << "p的地址是" << p << endl;

	delete p;				//会释放p指向的内存，但不会删除指针p

	int a = 521;
	p = &a;
	cout << "现在p指向了a的值" << *p;

使用new创建动态一维数组

	int* p = new int[3];			//方括号内写数组需要的元素，new将返回数组第一个元素的地址
	p[0] = 2;
	p[1] = 3;
	p[2] = 4;
	cout << p[2]<<endl;					//可以把指针当做数组名来用
	cout << *(p+1);						//将指针变量+1后，相当于加上其指向的类型的字节数

使用new创建动态二维数组

height个int*类型的指针(height行)，每个指针指向int[width]（width列）

第一种指针声明时是int**

void TestFunc_pointer(unsigned int height, unsigned int width)
{
	unsigned int i, j;
 
	// 	数组的元素类型为int *，可赋值给指向int *的指针.
	int **array2D = new int *[height];
	for(i=0; i<height; ++i)
	{
		array2D[i] = new int[width];
	}
 
	// 访问.
	for(i=0; i<height; ++i)
	{
		for(j=0; j<width; ++j)
		{
			// 内存非连续，注意防止越界.
			array2D[i][j] = i * width + j;
		}
	}
 
	// 首先回收低一级的动态数组.
 	for(i=0; i<height; ++i)
	{
		delete[] array2D[i];
	}
	// 然后回收高一级的动态数组.
	delete[] array2D;
}

引用

相当于一个别名

int a = 5;
int& b = a;			//必须在声明引用的时候初始化

指针数组和数组指针

指针数组——数组元素是指针  int *a[10]

 数组指针——指向数组的指针  int (*p)[10]

可以理解成int[10] *p(并不能这样写....)

	int a[3] = { 5,2,1 };

	int(*p)[3] = &a;	         //数组指针
	
    //p=&a; *p=a=&a[0]; **p=a[0] 
	

	int* h[3];					//指针数组
	h[0] = &a[0];
	h[1] = &a[1];
	h[2] = &a[2];

string类

常用的string类运算符：=、+、+=、==、!=、<、<=、>、>=、[]（访问下标对应字符）、>>（输入）、<<（输出）

示例：

#include <iostream>
#include <string>
using namespace std;

int main()
{
	string str1 = "ABC";
	string str2("dfdf");
	string str3 = str1 + str2;
	cout<< "str1 = " << str1 << "  str2 = " << str2 << "  str3 = " << str3 << endl;
	str2 += str2;
	str3 += "aff";
	cout << "str2 = " << str2 << "  str3 = " << str3 << endl;
	cout << "str1[1] = " << str1[1] << "  str1 == str2 ? " << (str1 == str2) << endl;
	string str = "ABC";
	cout << "str == str1 ? " << (str == str1) << endl;
	return 0;
}

控制输出所占列数

setw(int n)

枚举

不能用cin对枚举类型进行输入，但scanf可以
这是因为，
在C里面，enum类型其实就是int型
在C++里，比如定义enum sex{man,woman};
man 和woman是这个枚举的成员
而对于sex类型的变量只能使用这个集合中的元素来初始化，也就是说虽然man实际代表0,woman代表1，但在sex s 定义中，你不能写s = 0或s = 1， 而只能写s = man, s = woman