• C到C++入门基础知识

    一：命名空间：namespace

    （一）：命名空间的定义

    注：命名空间只能定义在全局，不能定义在函数内部。

    （1）类似于C语言的结构体，C语言的命名空间定义为：

    1. namespace  name{    // name是命名空间的名字
    2. //  
    3. }

    （2）命名空间里成员可以是：变量/函数/自定义类型变量/类，等。

    1. namespace xs {
    2. 	int age;
    3. 	char name[10];
    4. 	int ID;
    5.  
    6. 	struct xs{
    7. 		int height;
    8. 		char* hobies;
    9. 	};
    10.  
    11. 	void swap(int* num1,int*num2)
    12. 	{
    13. 		int tmp = *num1;
    14. 		*num1 = *num2;
    15. 		*num2 = tmp;
    16. 	}
    17. };

    （3）命名空间可以嵌套定义：

    1. namespace xs {
    2. 	int age;
    3. 	char name[10];
    4. 	int ID;
    5.  
    6. 	struct xs{
    7. 		int height;
    8. 		char* hobies;
    9. 	};
    10.  
    11. 	void swap(int* num1,int*num2)
    12. 	{
    13. 		int tmp = *num1;
    14. 		*num1 = *num2;
    15. 		*num2 = tmp;
    16. 	}
    17.  
    18.     // 嵌套一个老师的命名空间
    19. 	namespace teacher {
    20. 		char* subject;
    21. 		int work_year;
    22. 		char* name;
    23. 	}
    24. };

    （4）在不同文件中定义同一个名字相同的命名空间会被编译器识别为同一个命名空间：

    例如同一个项目中分别有两个.cpp文件，两个文件都有xs这命名空间，在编译的时候不会报错，编译器会将他们识别为同一个命名空间。

    （5）C++的标准库的命名空间是std(standard).

     

    （二）：命名空间的使用

    我们在命名空间中定义了变量，函数，类或者结构体等，如果我们没有解析命名空间，像C语言一样使用命名空间的对象和方法时会报错：

    1. namespace xs {
    2. 	int age;
    3. 	char name[10];
    4. 	int ID;
    5.  
    6. 	struct xs{
    7. 		int height;
    8. 		char* hobies;
    9. 	};
    10.  
    11. 	void swap(int* num1,int*num2)
    12. 	{
    13. 		int tmp = *num1;
    14. 		*num1 = *num2;
    15. 		*num2 = tmp;
    16. 	}
    17.  
    18. 	namespace teacher {
    19. 		char* subject;
    20. 		int work_year;
    21. 		char* name;
    22. 	}
    23. };
    24.  
    25. int main()
    26. {
    27. 	int a = 1;
    28. 	int b = 2;
    29.  
    30. 	swap(&a, &b);
    31.  
    32. 	return 0;
    33. }

    9657b2921ed74033a3facb4309b4d3ea.png

    在使用命名空间域内定义的变量的时候有以下几种方法：

    （1）指定命名空间访问：

    :: 符号被称为作用域解析运算符

    1. #include 
    2.  
    3. namespace xs {
    4. 	int age;
    5. 	char name[10];
    6. 	int ID;
    7.  
    8. 	struct xs{
    9. 		int height;
    10. 		char* hobies;
    11. 	};
    12.  
    13. 	void swap(int* num1,int*num2)
    14. 	{
    15. 		int tmp = *num1;
    16. 		*num1 = *num2;
    17. 		*num2 = tmp;
    18. 	}
    19.  
    20. 	namespace teacher {
    21. 		char* subject;
    22. 		int work_year;
    23. 		char* name;
    24. 	}
    25. };
    26.  
    27. int main()
    28. {
    29. 	int a = 1;
    30. 	int b = 2;
    31.  
    32. 	// 这里指定xs这个命名空间域
    33. 	xs::swap(&a, &b);
    34.  
    35. 	printf("a = %d \nb = %d", a, b);
    36.  
    37. 	return 0;
    38. }

    （2）使用using关键字将命名空间中的某个成员展开

    1. #include 
    2.  
    3. namespace xs {
    4. 	int age;
    5. 	char name[10];
    6. 	int ID;
    7.  
    8. 	struct xs{
    9. 		int height;
    10. 		char* hobies;
    11. 	};
    12.  
    13. 	void swap(int* num1,int*num2)
    14. 	{
    15. 		int tmp = *num1;
    16. 		*num1 = *num2;
    17. 		*num2 = tmp;
    18. 	}
    19.  
    20. 	namespace teacher {
    21. 		char* subject;
    22. 		int work_year;
    23. 		char* name;
    24. 	}
    25. };
    26.  
    27. // 展开xs中的swap函数
    28. using xs::swap;
    29. int main()
    30. {
    31. 	int a = 1;
    32. 	int b = 2;
    33.  
    34. 	// 这里我们去掉xs::不会报错
    35. 	swap(&a, &b);
    36.  
    37. 	printf("a = %d \nb = %d", a, b);
    38.  
    39. 	return 0;
    40. }

    （3）使用using关键字展开命名空间中的全部成员：这种方式容易产生命名冲突等问题

    1. #include 
    2.  
    3. namespace xs {
    4. 	int age = 10;
    5. 	char name[10] = "小明";
    6. 	int ID;
    7.  
    8. 	struct _xs{
    9. 		int height;
    10. 		char* hobies;
    11. 	};
    12.  
    13. 	void swap(int* num1,int*num2)
    14. 	{
    15. 		int tmp = *num1;
    16. 		*num1 = *num2;
    17. 		*num2 = tmp;
    18. 	}
    19.  
    20. 	namespace _teacher {
    21. 		char* subject;
    22. 		int work_year;
    23. 		char* name;
    24. 	}
    25. };
    26.  
    27. // 展开命名空间中的全部成员,可以不用域解析::就可以随便访问命名空间内的所有成员了
    28. using namespace xs;
    29. int main()
    30. {
    31. 	printf("age:%d\n name:%s", age, name);
    32.  
    33. 	return 0;
    34. }

    （三）：为什么要使用命名空间

    （1）.解决C语言命名冲突问题

    （2）.命名空间的本质是开出一个独立的域空间，C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所以有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的⽣命周期，命名空间域和类域不影响变量⽣命周期。

    二：输入输出：cout / cin

    说明：cout和cin是c++的标准输入输出类的对象，他们是标准库中定义的，用于窄字符（narrowcharacters(oftypechar)）的输入输出。

    （1）同C语言相比cout和cin不需要格式化，他们支持任意类型的输入输出，会自动将其他类型转换成字符串类型

    （2）cout/cin/（换行endl）等都被定义于C++标准库，因为C++标准库都放在std(standard)的命名空间中，所以使用的时候要解析命名空间。

    （3）有些编译器会间接包含printf和scanf函数，也就是说不包含 

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7. 	int age;
    8. 	char name[10];
    9. 	cin >> age >> name;
    10.  
    11. 	// 这里没有包含printf也可以正常使用
    12. 	printf("age:%d\tname:%s\n", age, name);
    13.  
    14. 	cout << age << endl;
    15. 	cout << name << endl;
    16.  
    17. 	return 0;
    18. }

    三：缺省参数

    定义：在定义函数的时候给予参数一个默认的缺省值。

    （1）半缺省，全缺省。

    半缺省：部分形参给予默认值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

    全缺省：全部形参给予默认值。

    （2）带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参。

    （3）含缺省参数的函数调用的时候，没有传参使用默认值，传参使用传递值。

    1. #include 
    2.  
    3. // 半缺省
    4. int Add1(int b, int c, int a = 0)
    5. {
    6. 	return a + b + c;
    7. }
    8.  
    9. // 全缺省
    10. int Add2(int a = 0, int b = 0)
    11. {
    12. 	return a + b;
    13. }
    14.  
    15. using namespace std;
    16.  
    17. int main()
    18. {
    19. 	int n1 = 2;
    20. 	int n2 = 3;
    21.  
    22. 	cout << Add1(n1,n2) << endl;
    23. 	// 全缺省的
    24. 	cout << Add2() << endl;
    25.  
    26. 	return 0;
    27. }

    （4）函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

    我们将.c文件的两个函数声明放到,h文件.c文件依然给缺省值8f8a9847e9b44ce5b500273610911e81.png

    c9e273398e5a42238c16faf218486518.png

    编译器报错：

    7ae3d12f5ce34d989c529e305d8102ba.png

    所以应该将.c文件中的缺省参数去掉

    四：内联函数：inline

    使用inline关键字修饰的函数被调用时会在调用处将函数定义展开

    （1）加上inline的函数，如果函数代码较多或者是递归，编译器会忽视不展开代码。

    （2）使用inline的本质是替换函数调用，提高程序执行的效率（因为函数调用需要建立函数栈帧，开辟空间等消耗），可以平替C语言的宏。

    （3）inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错

    使用inline，直接在函数的前面加个inline就可以了。

    1. inline int add(int a, int b)
    2. {
    3.     return a + b;
    4. }

    五：函数重载

    函数重载：即同名函数，提现了类的多态行为。

    满足函数重载的条件：

    1.函数的形参不同

    2.函数的参数个数不同

    3.形参的类型不同

    4.形参类型顺序不同

    1. // 函数的形参不同以及形参个数不同
    2. int add(int a, int b,int c = 1)
    3. {
    4. 	return a + b;
    5. }
    6. double add(double a, double b, int c = 1)
    7. {
    8. 	return a + b + c;
    9. }
    10.  
    11. // 形参不同和形参类型顺序不同
    12. void func(char c, int n)
    13. {
    14. 	cout << c << "  " << n << endl;
    15. 	printf("形参不同\n");
    16.  
    17. }
    18.  
    19. void func(int n, char c)
    20. {
    21. 	cout << c << "  " << n << endl;
    22. 	printf("形参类型顺序不同\n");
    23. }
    24.  
    25.  
    26. int main()
    27. {
    28. 	// 名字一样调用的是两个函数
    29. 	func('a', 4);
    30. 	func(4, 'a');
    31.  
    32. 	cout << add(1, 2) << endl;
    33. 	cout << add(1.0, 2.0, 3) << endl;
    34.  
    35. 	return 0;
    36. }

    b14bec1fb64c401b9589f9c4333c295d.png

    但是返回值不同不可以

    c50de625aa3b434f8a3a763d719865fa.png

    六：引用

    （一）引用的定义和特性

    （1）引用就是给一个对象起别名，不开辟内存空间。

    其基本格式为：类型& 引⽤别名 = 引⽤对象; （这里的&不是取地址）

    1. #include 
    2. using namespace std;
    3.  
    4.  
    5. int main()
    6. {
    7. 	int a = 0;
    8. 	int c = 5;
    9.  
    10. 	int& ra = a;
    11. 	int& rc = c;
    12.  
    13. 	// 对引用进行++
    14. 	ra++;
    15. 	rc++;
    16.  
    17. 	cout << "ra++后a:" << a << endl;
    18. 	cout << "rc++后c:" << c << endl;
    19.  
    20. 	cout << "ra的地址为：" << &ra << endl;
    21. 	cout << "a的地址为：" << &a << endl;
    22. 	cout << "rc的地址为：" << &rc << endl;
    23. 	cout << "c的地址为：" << &c << endl;
    24.  
    25. 	return 0;
    26. }

    146e630148c84f279d9fc2f7be1276ff.png

    （2）引用定义的时候必须要初始化：看吧。

    86ada2d0b9424c2dbe4b86a709d61100.png

    （3）⼀个变量可以有多个引⽤：跟一个人有多个绰号差不多

    1. #include 
    2. using namespace std;
    3.  
    4.  
    5. int main()
    6. {
    7. 	int a = 0;
    8. 	int c = 5;
    9.  
    10. 	int& ra = a;
    11. 	int& rra = a;
    12. 	int& rc = c;
    13.  
    14. 	return 0;
    15. }

    （4）引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体：

    （5）引用可以引用引用;

    1. int a = 0;
    2.  
    3. int& ra = a;
    4.  
    5. // 这样是可以的
    6. int& rra = ra;

    （二）引用的使用

    （1）引⽤在实践中主要是于引⽤传参和引⽤做返回值中减少拷⻉提⾼效率和改变引⽤对象时同时改变被引⽤对象

    例如在函数传参的时候

    1. void fun(int& x)
    2. {
    3. 	x++;
    4. }
    5.  
    6. int main()
    7. {
    8. 	int a = 0;
    9. 	fun(a);
    10. 	// 这里相当于将a取了一个别名，然后函数里面根据这个别名找到对应的对象进行运算
    11. 	cout << a << endl;
    12.  
    13. 	return 0;
    14. }

    （三）const修饰引用

    （1）const修饰引用可以使权限缩小，但是不能使权限放大，当然const修饰的应用对象是不能被修改的。

    1. // 定义一个变量
    2. const int a = 8;
    3.  
    4. // 权限放大，不允许，会报错的
    5. int& ra = a;
    6.  
    7. // 权限平替，这样可以
    8. const int& ra = a;
    9.  
    10. int b = 0;
    11. // 权限缩小
    12. int& rb = b;
    13. // 不允许
    14. rb++;
    15. // 允许
    16. b++;
    17.  
    18. // 权限缩小只是缩小引用的权限缩小，而不会影响引用的对象的权限。

    （2）引用可以引用临时对象：

    临时对象：在程序运行中产生的用于转换的值或者其他对象，例如：类型转换，函数传参（函数传参是临时拷贝，传地址就不会产生临时对象）。这期间就会产生临时对象。

    临时对象具有常性：

    1. void fun(int& x)
    2. {
    3. 	x++;
    4. }
    5.  
    6. void fun2(int x)
    7. {
    8. 	int& rx = x;
    9.  
    10. 	x++;
    11.  
    12. 	cout << rx << endl; // 这输出3
    13. }
    14.  
    15. int main()
    16. {
    17. 	int a = 0;
    18. 	fun(a);
    19.  
    20. 	// 这里相当于将a取了一个别名，然后函数里面根据这个别名找到对应的对象进行运算
    21. 	cout << a << endl;
    22.  
    23. 	const int n = 2;
    24.  
    25. 	int rn = n;
    26. 	n++;  // 这里不允许
    27.  
    28. 	// 这里int向double转换的时候产生了临时变量，权限被放大了。
    29. 	const double& rm = n * 3;
    30.  
    31. 	// n是const修饰的变量，传递给函数，传递的是它的一份临时拷贝
    32. 	fun2(n);
    33.  
    34. 	cout << rm << endl; // 这里输出6
    35. 	return 0;
    36. }

    （四）指针和引用的区别

    （1）指针需要开辟空间，指针变量存储的是空间的地址。引用不需要开空间，他是所引用对象的另一个别名。

    dc2f10bc354e417faf31eeed4c043eb5.png

    （2）引用定义的时候就必须要初始化，指针可以不用

    1. int& r;
    2.  
    3. // 指针不初始化没问题，编译器不会初始化，但是这样就成了野指针，不建议这样搞
    4. int* ptr;

    （3）指针容易出现空指针和野指针，引用不容易出现空引用，引用比指针更安全。

    空引用：

     

    （4）引⽤可以直接访问指向对象，指针需要解引⽤才是访问指向对象。

    （5）引⽤在初始化时引⽤⼀个对象后，就不能再引⽤其他对象；⽽指针可以在不断地改变指向对象。

    1. int main()
    2. {
    3. 	int a = 0;
    4. 	int& b = a;
    5. 	int d = 5;
    6. 	b = d;
    7.  
    8. 	int* p = &a;
    9. 	cout << p << endl;
    10. 	p = &d;
    11. 	cout << p << endl;
    12.  
    13. 	cout << "a和b的地址" << endl;
    14. 	cout << &a << endl;
    15. 	cout << &b << endl;
    16.  
    17.  
    18. 	return 0;
    19. }

    5e923efd384345de9d2b8b66b171c14b.png

    （6）sizeof中含义不同，引⽤结果为引⽤类型的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)

    七：nullptr和NULL的区别

    NULL在C++中被定义为了宏0，容易导致和整型的0混淆使用，而nullptr不会出现这种情况，C语言支持NULL不支持nullptr。C++都支持。

    1. int main()
    2. {
    3. 	// 这里明着给int类型的a赋值指针但是没报错
    4. 	int a = NULL;
    5. 	printf("%d", a);
    6.  
    7. 	return 0;
    8. }

    48b55ddc46494f01964169fa51ad5642.png

     

     

  • 相关阅读:
    69.x的平方根
    Python-Django-Apache2.4-mod_wsgi-mysql-服务器生产环境配置
    Android 13.0 添加自定义服务，并生成jar给第三方app调用
    java-php-python-ssm水星家纺网站计算机毕业设计
    9.1 C++ STL 排序、算数与集合
    【Linux】详解套接字编程
    STM32_FSMC_HAL（介绍）
    protobuf 中数据编码规则
    程序员追星 - Patrick Winston
    面试官：什么是MySQL 事务与 MVCC 原理？
  • 原文地址：https://blog.csdn.net/2302_79306764/article/details/142177758