c++笔记（1）

hahahasxws

已于 2022-03-04 10:44:47 修改

阅读量354

点赞数

分类专栏： C语言文章标签： c++ p2p 开发语言

于 2022-01-08 12:41:22 首次发布

本文链接：https://blog.csdn.net/hahahasxws/article/details/122378550

版权

C语言专栏收录该内容

13 篇文章 0 订阅

订阅专栏

对于c与c++的区别

c主要是对其思考过程的一个语言，更注重程序的逻辑实现，更直接的完成某一种功能

c++则是主要面向对象的编程语言，更注重程序的整体设计，后期更容易对其进行优化，维护以及管理，让一个功能不仅仅是只应用到当前的项目，尽可能的使其通用，面对对象的三大特性：封装继承以及多态

1.c+的复用性，扩展性以及封装性

在对与使用一个外部函数的时候，c+可以对其有更好的复用性，扩展性，以及封装

//template<typename T>
//T Add(T a,T b){
// return a+b;
//}进行一个复用性，可以使用一个，重复进行使用，进行某一类进行开发，
这种例子就可以对任何类型都使用这种，函数类型
struct s_add//封装
{
	int add(int a, int b)
	{
		return a + b;
	}
	double add(double a, double b)
	{
		return a + b;
	}//扩展性，在同一个结构体中，可以对多个函数进行增加
	
};
int main()
{
	s_add s_add1;//定义一个s_add1的函数
	s_add1.add(3, 4);//调用函数中的add函数，当传入不同的实参的时候，
    就会自动选择在struct中的对象
	return 0;
}

2.c+的命名空间

c+在使用的时候跟c一样，要包括一个固定的头文件

#include <iostream>//io输入输出 stream流
using namespace std//using namespace 命名空间名,打开一个关于std空间
int a=10;//这个是全局变量a
int main()
{
int a =20;
cout<<a;//输出的是局部变量20
cout<<::a;//用这种方法就可以对全局变量进行输出，输出的就是10
}

也可以使用namespace在全局变量中建立一个结构体

#include <iostream>
using namespace std;
//using namespace 命名空间名
//手动指定命名空间以及成员AA::a;
//显示的指定使用命名空间，using namespace AA
namespace AA
{
	int a = 30;
	void show()
	{
		cout << "AA输出的是"<<endl;
	}
};//建立一个AA的空间，里面包含各种对象，可以通过调用结构体，来得到对应的对象
namespace BB
{
	int a = 40;
void show()
	{
		cout << "BB输出的是"<<endl;
	}
};
//int a = 20;//因为作用域的不同，全局变量中的a与局部变量的a能够分辨出来，但是出现多个全局变量a就会导致辨别不出来，就可以创建出一个namespace的空间来保存
//这个时候时候就把AA的储存空间打开了
//优先级顺序递减， int a=    ,using AA::a,   using namespace 
//using space AA;//把AA这个结构体打开了，里面的a就相对于是全局变量，在使用的过程中，只允许将同名中的一个结构体打开，要不然就会出现重复定义的现象
int main02()
{
	int a = 10;
	//cout<<::a<<endl;表示对全局变量中的a进行打印
	//也可以特定对外部空间的变量进行读取
	cout <<AA:: a << endl;
	return 0;
}

3.输入输出

cin>>

cout<<

#include<iostream>  //iostream 输入输出流
using namespace std;//打开一个标准命名空间
int main()
{
	int a = 10;
	char b = 'c';
	cout<< a << "  " << (int)b << endl;//对于ab这种类型的输出，在输入什么的时候就已经定义了，如果想要得到固定的类型，就需要强制转换
	cin >> a >> b;
	cout << a << "  " << (int)b << endl;
	scanf("%d %c", &a, &b);
	printf("%d %c", a, b);//可以通过更改输出的类型，来直接得到一个字符或者是他的十进制数
	system("pause");//return 0 直接退出，system("pause")相当于增加一个暂停键，可以使用断点调试
	return 0;
}

4.动态类型

在学习c的内容时候，对动态空间的开发，使用的是malloc以及free的方法，在c+这里使用了一个新的方法，增加了一个关键字的使用，new以及delete

使用new要主要他返回的类型是，是一个void类型的指针，简单理解：要是普通的类型返回，前端就是以及指针，要是是创造了一个一级指针并且返回，那么这个一级指针所返回的就

#include <iostream>
using namespace std;
int main()
{
	//malloc free与new delete
	/*
	区别：
	1.new delete C++关键字，编译器的支持。malloc free是函数，需要头文件进行支持
	2.malloc需要显示指定需要的空间大小（byte），new需要类型，根据类型自动计算所需空间
	3.malloc返回的是void *类型，需要进行强转，new不需要
	******4.new delete申请是，释放，对象内存空间。会自动调用构造函数，析构函数
	*/
	//c中的动态空间
	int *p=(int*)malloc(sizeof(int));
	free(p);
	*p = NULL;//C中的动态使用堆的创建以及释放
	
	
	//C++中的动态数组
	//对于整形的
	//int* p2 = new int;//定义了一个大小是int的空间，这个空间现在的赋值是一个乱值
	//int* p2 = new int();//加一个括号代表这个新开的空间赋值为0
	int* p2 = new int(10);//开出的空间赋值了为10
	delete(p2);//对p2所指的空间进行释放
	p2 = NULL;
	
	//对于数组
	//int* p3 = new int[10];//开出一个数量为10的数组空间
	//int* p3 = new int[10]();//初始值赋值为0
	int* p3 = new int[10]{1,2};//对数组中的值进行赋值，需要用大括号{}
	delete []p3;//对数组p3进行空间释放，前面必须加一个[]
	p3 = NULL;
	

	//------------
	int* *p4=new int*;//指针的地址
	int **p5=new int* [4];//指针数组

	int  (**p6)[]=new (int(*)[]);//数组指针
	typedef int(*p_arr)[];//将这个复杂的指针类型用一个名字代替，看上去更直观
	p_arr* p7 = new p_arr;//另一种方法对数组指针进行表示
	
	int(*p8)[3] = new int[2][3];//二维数组
	system("paise");
	return 0;
}

5.bool类型

        BOOL windows系统提供int的别名，bool c++的关键字
        TRUE FALSE 宏定义， true false关键字
        BOOL类型变量占用四个字节， bool占用一个字节

#include <iostream>
using namespace std;
#include<windows.h>
/*
BOOL windows系统提供int的别名，bool c++的关键字
TRUE FALSE 宏定义， true false关键字
BOOL类型变量 占用四个字节， bool占用一个字节
*/
int main()
{
	bool b1 = true;
	cout << sizeof(b1) << sizeof(bool)<< endl;//1,1
	BOOL b2 = TRUE;
	cout << sizeof(b2) << sizeof(BOOL) << endl;//4,4

	//遍历
	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (int i = 0; i < 10; i++)
	{
		cout << a[i] << endl;

	}
	//另一种方法进行遍历
	for (int val : a)
	{
		cout << val << endl;//运用这种方法，对数组a进行遍历
	}
	system("pause");
	return 0;
}

6.字符串

在c中使用字符串的时候，需要使用char或者数组，对字符串的使用比较晦涩

在c+中，增加了对字符串的使用，可以添加一个头文件#include<string>,直接使用里面的string，利用string定义一个字符串，并且很多功能都是c+中自带的

直接可以进行使用

#include <iostream>
#include <string>
using  namespace std;
#define _CRT_SECURE_NO_WARNINGS
int main()
{

	const char* p1 = "sdasd";
	cout << p1 << endl;
	p1 = "ada";

	char arry[10] = "132156";
	arry[1] = '9';
	cout << arry << endl;

	/*char* p2 = new char[10];
	
	cout << p2 << endl;*/

	string str1 = "dasd";
	cout << str1 << endl;
	st1 += "1111";
	cout << st1 << endl;//对字符串进行添加


	string str = str1.substr(0, 2);
	cout << str1 << endl;

	cout << str1.size() << endl;   //获取字符串长度
	cout << str1.length() << endl;

	cout << str[1] << endl;
	for (int i = 0; i < str.length(); i++) {
		cout << str[i] << endl;
	}

	for (char c : str) {  //遍历字符串
		cout << c << endl;
	}
	str = "";

	if (str.empty()) {  //判断是否为空
		cout << "empty" << endl;
	}

	str = "123456";
	int a = str.find("23");
	cout << a << endl;
	str.
	return 0;

}

7.nullptr--空指针

#include <iostream>
using namespace std;
void play(int p) {
	cout << "1" << endl;
}
void play(int *p) {
	cout << "2" << endl;
}
void play(char * p) {
	cout << "3" << endl;
}

int main01()
{

	/*
	nullptr和NULL的区别
	1.nullptr是关键字   NULL是宏  #define NULL 0
	2.含义不同，nullptr是指的空指针 NULL是整形0
	*/
	play(NULL);//优先指向play(int p)---------当没有指明的时候，优先指向整形
	//play(nullptr);
    //有一个不是指针，有一个是指针的时候，就能分辨出指向哪个
    //当形参都是指针的时候，不知道这个指针是指向哪个函数的指针，具体是指向int*还是char*
	play((int *)nullptr);//这种时候对这种指针进行强转就可以，指定输出什么类型的函数
	system("pause");
	return 0;

}

8.函数重载

#include <iostream>
using namespace std;
void show(int a, char b = 'c');
/*
	可以在函数声明的位置，对参数进行默认赋值
	只能在声明处（或者是声明定义都有，必选是一样）
	！！！！！从右往左依次指定，不能间断
*/
void play(int a, int b);
void play(int a, char b);
/*
	函数重载
	在同一个作用域下，函数的名字相同，参数不同（只要里面的参数顺序不同，类型不同）
	编译器就可以根据函数中传入的实参不同，自动分辨调用哪个函数
*/
/*
 void play(int *p);
 void play(int arryp[]);
 不是函数重载，是属于重定义

*/
int main()
{
	show(10);
	play(10, 20);
	play(10, 'a');
	return 0;
}
void show(int a, char b)
{
	cout << a << "  " << b << endl;
}
void play(int a, int b)
{
	cout << a << "  " << b << endl;
}
void play(int a, char b)
{
	cout << a << "  " << b << endl;
}

9.引用

#include<iostream>
using namespace std;

void show(int c)
{
	 c = 20;
}
void show(int *c)
{
	*c = 20;
}
void show1(int & c)
{
	c = 30;
}//引用跟指针的使用方法很相似

/*
应用和指针的区别：
1. 引用定义就要初始化， 指针可以不用初始化（不推荐）。
2. 引用一旦引用某个空间，就不能再引用其他空间，指针可以修改其指向的空间
3. 有空的指针，没有空的引用。
4. 引用不会额外开辟空间，指针会开辟存储地址的空间。
5. 指针可以有级，引用不能有多级。
*/
void func(int** pp, int size) {

	*pp = new int[size];
	for (int i = 0; i < size; i++) {
		(*pp)[i] = i;
	}
}

void func(int*& pp, int size) {

	pp = new int[size];
	for (int i = 0; i < size; i++) {
		(pp)[i] = i;
	}
}//引用来代替指针p，

void showfunc(int* p, int size) {
	for (int i = 0; i < size; i++) {
		cout << p[i] << "    ";
	}
	cout << endl;
}
int main()
{

	int* p = nullptr;//定义一个空指针

	func(&p,10);//定义一个声明，转去func(int*& pp, int size) 
	func(p, 10);
	showfunc(p, 10);

	delete []p;


	int a = 10;
	int& b = a;//这个&不是取地址符号，是对a进行引用，b的地址跟a的地址一摸一样，可以把b就当作是a 
	cout << a << b << endl;
	
	show(a);//并不会改变a的值，在函数中的参数是函数中的，并不会影响函数中的
	cout << a << b << endl;
	
	show(&a);//可以利用指针来改变函数中的内容
	cout << a << b << endl;
	
	show1(a);//直接应用引用，来改变函数中的数
	cout << a << b << endl;
	return 0;
}