C++基础阶段入门 （1）

1.C++统一初始化:

    初始化列表解决方案：

//C语言的初始化方案
int main()
{
	int a = 10;
	int* ip = nullptr;
	int ar[] = { 12,23,34,45,56,67 };
}

C++ 初始化：使用{ }

int main()

{
	//char ch = 'a';
	char ch{ 'a' };

	//int a = 10;
	int a{ 10 };
	int b = int(10);
	int x{ 10 };
	int y = int{ 10 };

	//double* ip = nullptr;
	double* ip{ nullptr };

	int ar[] = { 1,2,3,4,5,6 };
	int br[]{ 1,2,3,4,5,6 };
	return 0;
}

2.输入输出

 C++的输入输出

#include<iostream>
using namespace std;

int main()
{
	int a{};
	char ch{};
	//scanf_s("%d", &a);
	//scanf_s("%c", &ch);

	cin >> a >> ch;  //cin输入流对象

	//printf("a=%d ch=%c \n", a, ch);
	cout << a << "\t" << ch << endl;   //endl=> \n;
	cout << a << " " << ch << endl;   // \n;


	return 0;
}

int main()
{
	int a{ 10 }, b{ 20 };
	printf("a=%d b=%d\b", a, b);
	cout << "a=" << a << "b=" << b << endl;
	return 0;
}

注： 

       使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含<iostream >头文件以及std标准命名空间endl相当于'/n'；

字符串的输入：

int main()
{
	char str[128]{};
	//cin >> str;

	cin.getline(str, 128);      //127 \0
	cin.getline(str, 128, '#');     

	cout << str << endl;
	return 0;
}

3.const 与指针

const 在C与C++的区别：

int main()
{
	const int n = 10;
	int ar[n] = { 1,2,3,4 };
	int* p = (int*)&n;
	*p = 100;
	printf("n=%d *p=%d\n", n, *p);
	return 0;
}

C++以常量为主  C语言以变量为主 

 

const与指针的关系：

int main()
{
	int a{ 10 }, b{ 20 };      //指针自身的值 指针所指之物的值
	int* ip1 = &a;             // *ip1 = 100;ip1=&b;

	const int* ip2 = &a;        //const修饰自身指向能力时， 指向不可修改 自身可以修改
	int const* ip3 = &a;        //ip2=&b

	int* const ip4 = &a;         //const修饰ip自身 *ip4=100;
    const int* const ip5 = &a;   //都不能修改

	return 0;
}

 A：const修饰自身指向能力时， 指向不可修改 自身可以修改， 指向为常性 在赋值的时候

//1  不能给普通指针，无法编译通过  能力扩展了 

//3  const修饰指针自身 没有修饰指向

 B:  const修饰p自身   

 

4.引用（别名）

引用的定义
类型& 引用变量名称 = 变量名称
这就是引用变量的定义。&和类型结合称之为引用符号，不是取地址的符，代表别名的意思。

1 引用没有定义,是一种关系型声明。声明它和原有某一变量(实体)的关 系。故 而类型与原类型保持一致,且不分配内存。与被引用的变量有相同的地

址。

2 声明的时候必须初始化,一经声明,不可变更。

3 可对引用,再次引用。多次引用的结果,是某一变量具有多个别名。

4 &符号前有数据类型时,是引用。其它皆为取地址

int main()
{
	int a = 10;
	int b = a;
	int& c = a;
	
	return 0;
}

 

 引用的特点：

int main()
{
	int a{ 10 };
	int& b=a;   //int *ip{nullptr}
}

 const引用：

//引用
int main()
{
	int a{ 10 };
	const int b{ 20 };   //常变量

	int& x = a;     //普通引用引用普通变量
	int &x = b;   //error  不能拿普通引用引用常变量

	//常性引用是万能引用
	const int& x = b;    //ok  常引用可以引用常变量
	const int& y = a;    //ok  常引用可以引用普通变量  y只能读取a的值   不能通过y去修改a的值
	const int& z = 10;   //ok  常引用可以引用字面常量  

	return 0;
}

引用作为形参代替指针：

void Swap(int *ap, int *bp)  //形参是指针
{
	assert(ap != nullptr && bp != nullptr);
	int tmp = *ap;
	*ap = *bp;
	*bp = tmp;

}
int main()
{
	int x = 10, y = 20;
	Swap(&x,&y);
	cout << "x=" << x << "y=" << y << endl;
	return 0;
}

使用引用交换两个整型值

 其他引用：

 

 1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针

 2）引用相对于指针来说具有更好的可读性和实用性

5.缺省参数 

        一般情况下，函数调用时的实参个数应与形参相同，但为了更方便地使用函数，C++也允许定义具有缺省参数的函数，这种函数调用时，实参个数可以与形参不相同。

        缺省参数指在定义函数时为形参指定缺省值（默认值)。

        这样的函数在调用时，对于缺省参数，可以给出实参值，也可以不给出参数值。如果给出实参，将实参传递给形参进行调用，如果不给出实参，则按缺省值进行调用。

        缺省参数的函数调用:缺省实参并不一定是常量表达式，可以是任意表达式，甚至可以通过函数调用给出。如果缺省实参是任意表达式，则函数每次被调用时该表达式被重新求值。但表达式必须有意义; 

int my_rand()
{
	srand(time(nullptr));
	int ra = rand() % 100;
	return ra;
}

void func(int a, int b = my_rand())
{
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
}
int main()
{
	func(1);
	return 0;
}

 当缺省实参是一个表达式时在函数被调用时该表达式被求值。

 6.函数重载

 C语言实现int,double,char 类型的比较大小函数：

       函数重载(Function Overload)：用同一个函数名定义不同的函数，当函数名和不同的参数搭配时函数的含义不同。

       在C++中可以为两个或两个以上的函数提供相同的函数名称，只要参数类型不同，或参数类型相同而参数的个数不同， 称为函数重载。

 

void func(int a,char ch){}
void func(char ch,int a){}

int main()
{
	func(12, 'a');
	func('a', 12);

	return 0;
}

 

 1.如果两个函数的参数表相同，但是返回类型不同，会被标记为编译错误: 函数的重复声明

 ⒉参数表的比较过程与形参名无关。 

 3.如果在两个函数的参数表中，只有缺省实参不同，则第二个声明被视为第一个的重复声明。 

 4.注意函数调用的二义性;

 如果在两个函数的参数表中,形参类型相同,而形参个数不同,形参默认值将会影响函数的重载.

 5.当一个形参类型有const或volatile修饰时,如果形参是按值传递方式定义,在识别函数声明是否相同时,并不考虑const和volatile修饰符. 

 6.当一个形参类型有const或volatile修饰时,如果形参定义指针或引用时,在识别函数声明是否相同时，就要考虑const和volatile修饰符. 

总结:
函数重载的依据
返回类型不同的函数是否可以重载。
参数带有默认值的情况
为什么C++可以函数重载而C语言不可
名字粉碎。
extern 关键字的使用