C++基础知识001

最新推荐文章于 2024-08-02 19:40:03 发布

原创最新推荐文章于 2024-08-02 19:40:03 发布 · 317 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++

C/C++ 专栏收录该内容

51 篇文章

订阅专栏

1、C++简介

C++是在C语言的基础上进一步优化而来的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

2、命名空间：用来避免标识符命名污染与命名重复的。

命名空间的定义及使用

// 命名空间：用来避免C语言中的命名冲突
// :: 作用域限定符
// 命名空间的定义
// 命名空间的使用：
// N::a
// using N::a
// using namespace N
namespace N{
	// 放变量
	int a = 10;
	// 放函数
	int Add(int left, int right);
	
}

// 命名空间支持嵌套定义
namespace N {
    namespace N1 {
    }
}



int main(){
	cout << N::a << endl;

	return 0;
}

注：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

3、缺省参数：是声明或定义函数时为函数的参数指定一个默认值

//  缺省参数：不能在函数声明和定义中同时出现
// 全缺省参数：
// 部分缺省参数：只能按顺序缺省

void Testfun(int a = 10, int b = 20){
	cout << a << endl;
	cout << b << endl;

}

void TestFunc(int a, int b){
	cout << a << endl;
	cout << b << endl;
}

void TestFunc(int a, int b = 10){
	cout << a << endl;
	cout << b << endl;
}

注：1. 半缺省参数必须从右往左依次来给出，不能间隔着给

2. 缺省参数不能在函数声明和定义中同时出现

3. 缺省值必须是常量或者全局变量

4. C语言不支持（编译器不支持）

4、函数重载：C++中用来解决功能类似数据类型不同的问题的同名函数。

// 函数重载
// 类型不同 


int add(int a, int b) {
	return a + b;
}

double add(double a, double b) {
	return a + b;
}

// 仅仅返回值类型不同不能构成重载函数
//double add(int a, int b) {
//	return a + b;
//}

// 参数个数不同

int add(double a, int b, float c) {
	return a + b + c;
}

// 类型顺序不同

int add(int a, double b, float c) {
	return a + b + c;
}

int main() {
	
	cout << add(1,2) << endl;
	cout << add(1.0, 2.0) << endl;
	cout << add(1.0, 2, 3.2) << endl;
	cout << add(1, 2.0, 3.2) << endl;
	system("pause");
	return 0;
}

// 名字修饰(编译过程，编译器为了区分各个函数，将函数通过某种算法，重新修饰为一个全局唯一的名称
// 程序运行过程：预处理、编译、汇编、链接

// c语言的名字修饰就是在函数名字前加下划线，如：_add
// C++的命名修饰比较复杂，不同环境下都是不一样的


// C++中在函数名前使用extern "c"  可以让该函数按照C语言风格运行

5、引用：变量的别名，与所引用的变量共用同一块内存空间。

// 引用（相当于一个别名，与实体共用同一块内存空间，在底层中按照指针方式处理）
//1. 引用在定义时必须初始化
//2. 一个变量可以有多个引用
//3. 引用一旦引用一个实体，再不能引用其他实体
// 引用必须与实体类型相同

// 引用作为参数
// 使用传引用实现两个数的交换
void swap(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}


// 引用作为函数返回值
// 注意：函数返回后引用的空间就是无效空间了，所以在使用引用作为函数返回值时，返回值的生命周期必须比函数长
//
//int& add(int a, int b) {
//	int ret = a + b;
//	return ret;
//}


int ret;
int& add(int a, int b) {
	ret = a + b;
	return ret;

}
int main(){

	//int a = 10;
	//int& ra = a;  // 类型后面加& 为引用，引用必须初始化
	//ra = 20;

	int a = 10;
	int b = 20;

	swap(a, b);   // 函数调用时只用传值就可以
	cout << a << " " << b << endl;

	int& result = add(3, 4);
	add(4, 5);
	cout << result << endl;
	system("pause");
	return 0;
}



// 传值、传地址、传引用效率比较

// clock函数用于计算进程时间
#include <time.h>
struct A {
	int a[10000];
};

// 传值
void func1(A a) {

}

// 传地址

void func2(A* a) {

}
// 传引用
void func3(A& a) {

}


void func_time() {
	A a;


	// 传值
	size_t start1 = clock();
	for (int i = 0; i < 10000; i++){
		func1(a);
	}
	size_t finish1 = clock();


	// 传地址
	
	size_t start2 = clock();
	for (int i = 0; i < 10000; i++){
		func2(&a);
	}
	size_t finish2 = clock();

	// 传引用

	size_t start3 = clock();
	for (int i = 0; i < 10000; i++){
		func3(a);
	}
	size_t finish3 = clock();

	// 分别计算两个函数运行结束后的时间
	cout << "传值时间:" << " " << finish1 - start1 << endl;
	cout << "传址时间：" << " " << finish2 - start2 << endl;
	cout << "传引用时间：" << " " << finish3 - start3 << endl;

}
int main() {

	// 多次运行，比较效率
	for (int i = 0; i < 10; i++){
		func_time();
	}

	system("pause");
	return 0;
}


// 对比后发现传值效率最低，传地址和传引用效率差不多

引用和指针的不同点:

1. 引用在定义时必须初始化，指针没有要求

2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

3. 没有NULL引用，但有NULL指针

4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4 个字节)

5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

6. 有多级指针，但是没有多级引用

7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

8. 引用比指针使用起来相对更安全

6、内联函数：使用inline修饰的函数，无压栈开销，可大大提高程序运行效率。

// 内联函数   inline修饰的函数
// 使用内联函数可以避免函数压栈，从而大大提高了程序的运行效率

inline int Add(int a, int b) {
	return a + b;
}
int main() {
	int a = 10;
	int b = 20;
	cout << Add(10, 20) << endl;
	system("pause");

	return 0;

}

注：

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。

2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。

3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

宏的优缺点：

优点： 1.增强代码的复用性。

2.提高性能。

缺点： 1.不方便调试宏。（因为预编译阶段进行了替换）

2.导致代码可读性差，可维护性差，容易误用。

3.没有类型安全的检查。

7、C++11中auto关键字的使用

// auto 关键字    auto声明的变量必须由编译器在编译时期推导而得。

// auto 不能用来修饰函数形参
//void test(auto a) {
//	return a;
//
//}



// auto 与范围for搭配使用
// 范围for指的是能够确定循环范围


void print() {
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int size = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < size; i++)
		cout << arr[i] << " ";
	cout << endl;


	for (auto e : arr)
		cout << e << " ";
	cout << endl;

}
int main() {
	// auto arr[] = { 1, 2, 3, 4 };     // auto 不能用来声明数组
	auto a = 10;   // auto 定义的变量必须初始化
	auto b = 10, c = 20;   // auto 同时定义多个变量时初始化表达式类型必须相同
	cout << a << endl;
	print();

	

	// C++ 11 中的空指针
	auto a = 10;

	auto p = &a;         // 使用auto 定义指针
	auto* p = &a;
	auto p = nullptr;    // C++中空指针默认使用nullptr

	auto& ra = a;    // 使用auto 定义引用
	ra = 20;

	system("pause");
	return 0;
}