C++学习笔记01

C++的发展史和C++标准

C++ 是由 Bjarne Stroustrup 于 1979 年在新泽西州美利山贝尔实验室开始设计开发的。C++ 进一步扩充和完善了 C 语言，最初命名为带类的C，后来在 1983 年更名为 C++。

C++的应用领域

①服务器端开发

②游戏开发

③虚拟现实

④数字图像处理

⑤科学计算

⑥网络软件

⑦操作系统

C++常用框架和库

C++ 头文件位置 /usr/include/c++/xxx/

（1）C++程序test.cpp

#include <iostream>
//iostream
//istream-->cin   
//ostream-->cout

//命名空间、名字空间
using namespace std;
int main(void)
{
	int a,b;
    char c;
    cin>>a>>c>>b;
    cout<<a<<c<<b<<endl;
    return 0;
}

（2）C++和C的关系

​ C++是C的超集，任何合法的C程序都是C++程序，但是在C++中会丢弃一些C中的部分操作。

（3）头文件

a、直接用C语言的方式写在代码前

b、一般把.h后缀去掉，在前面的加 c

c、如果需要使用的头文件，c++中没有改写

​ extern “C”

{

#include <pthread.h>

}

extern “C”表示当编译它里面的代码时，应该采用C的编译和链接方式进行编译和链接，这样可以实现C和C++的混合编程。

（4）标准输入输出

1）标准输入流：cin

istream的类对象

2）标准输出流：cout

ostream的类对象

3）标准出错流：cerr

4）标准日志流：clog

int main(void)
{
	int a,b,c;
	char str[10] = {0};
	cin >> a >> b >> c >> str;
	//scanf("%[^\n]",str);   //可以输入带空格的字符串
	cout << str << endl;     
	
	cerr << "this is a fatal error" << endl;    
	clog << "this is a log file" << endl;     
}

（5）C++的数据类型

基本数据类型：

char	bool	short	int 	long(4,8)	float	
double	long long	long double(12,16)

字符串类型：

1、C风格的字符串：char * 、char[]

char str1[20] = “hello”;//栈

char *str2 = “hello”;//常量区

操作字符串的函数：

strlen、strcpy、strcat、strcmp、strtok、strstr、strchr、strrchr

2、string类

string str1 = “hello” 

string str2(“hello”);

操作字符串的函数：

1）拼接

·用“+”实现：string s = str1+str2+”abc”;

·用append函数实现：string s = str1.append(str2).append(“abc”);

2）计算字符串的长度：length()和size()

string s = “hello”;

cout << s.length() << endl; //5

cout << s.size() << endl;  //5

3）比较字符串的大小

·用 “> < ==” char */char[] 比较的是地址）

char str1[10] = “hello”;

char str2[10] = “hello”;

if(str1 == str2)             //×

if(strcmp(str1,str2) == 0)      //√ 

string s1 = “hello”;

string s2 = “hello”;

if(s1 > s2)                     //√

if(s1 == s2)                   //√

if(s1 < s2)                     //√

·用compare函数实现

if(str1.compare(str2) > 0)

if(str1.compare(str2) == 0)

if(str1.compare(str2) < 0)

4）查找子字符串：find()

string s1 = “www.baidu.com”;

string s2 = “www”;

int ret = s1.find(s2); //如果找到了就返回子字符串的位置，找不到就是-1

5）字符串分割：substr

string s1 = "www.baidu.com";

string s = s1.substr(0,3);

cout << s << endl;

s = s1.substr(4,5);

cout << s << endl;

s = s1.substr(10,3);

cout << s << endl;

6）替换字符串：replace

string s1 = "www.baidu.com";

s1.replace(4,5,”12345”);   //从第4个位置开始替换5个字符

s1.replace(4,5,””);     //删除字符串

7）插入字符串：insert

string s1 = "www.baidu.com";

s1.insert(13,”.cn”); 

char */char[] 和 string的区别：

char */char[]要提前分配好空间，string会自动分配空间

char */char[] 和 string的相互转换：

char */char[]转string：

char *str1 = “hello”;

string str2 = str1;  

string转char */char[]：data()和c_str()【推荐】

string s1 = “hello”;

const char *s2 = s1.data();  //or s1.c_str();

char *s3 = (char *)s2; 

思考：string占多少字节？

由于各个系统对string类实现的方式有所差异，所以所占的字节数也不同，可能占4、8、12、24、32，但是有一个共同特点，无论string存放多少字节的字符串，它的sizeof都是固定的。

（6）命名空间

作用：避免重名冲突

定义：

namespace 空间名
{
    //1.变量的声明和定义
    //2.常量
    //3.函数的声明和定义
    //4.结构体的声明和定义
    //5.类的声明和定义
    //6.嵌套命名空间
}

访问被同名局部变量覆盖的全局变量：::变量名（不管有多少层覆盖，都是访问全局）

命名空间的使用：

1、直接写使用命名空间名 using namespace 命名空间名

eg:

​ using namespace std;

后面使用的标识符都会在命名空间中寻找

2、用到什么就写什么 using 命名空间名::标识符;

using std::cin;

using std::cout;

using std::endl;

using std::string;

后面出现的标识符没有特地指明，就是声明的这个标识符

3、**用到的时候再写 命名空间名::标识符

std::cout、std::cin、std::endl、std::string

4、可以续写命名空间

如果涉及到命名空间嵌套的，作用域运算符可以叠加：AAA：：BBB：：a；

匿名命名空间 — 相当于全局变量，直接使用

注意：

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

（2）命名空间可以分开定义，并且可以定义不同的文件中

（7）引用和指针

1、指针

​ 数据类型 *指针变量名 = 地址；

​ int a = 10;

​ int *p = &a;

2、引用

​ 就是变量的一个别名

​ int a = 10;

​ int &b = a; //给变量a取一个别名

​ 注意：

​ &是起一个标志作用，b是一个引用

​ 引用类型和变量类型必须一致

​ 定义引用时必须要初始化

​ 引用只是取名字，不会多占内存空间

​ 引用只能有一个对象，且不能更改

​ 引用的用法：

​ 1、函数参数传递时

​ 值传递 地址传递 引用传递

​ 2、函数返回值为引用

​ 只能返回全局变量、静态变量、堆空间变量

函数传参的方式：

（1）值传递，无法改变实参的值

（2）地址传递，可以改变实参的值

（3）引用传递，可以改变实参的值

引用和指针的区别：

​ 1、引用在创建必须初始化，指针可以不用

​ 2、引用不能为NULL，而指针可以

​ 3、引用一旦初始化，就不能改变引用的对象，而指针可以

为什么要发明引用？

用恰如其分的工具完成恰如其分的工作，尽管指针强大，但是很危险，如果只需要借助一下别名，就没有必要指针。

test.cpp

#include <iostream>
using namespace std;

int num1,num2,num3;

int &fun(int cnt)
{
    if(cnt == 0)
        return num1;
    else if(cnt == 1)
        return num2;
    else 
        return num3;
}

void swap(int &a,int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

int main(void)
{
    int a = 10;
    int &x = a;
    int y = 20;
    swap(x,y);
    cout<<"x "<<x<<endl;
    cout<<"y "<<y<<endl;
    fun(0) = 2;
    cout<<fun(0)<<endl;	//2
    cout<<num1<<endl;	//2
}

（8）函数的默认参数

​ c++中的函数参数可以使用默认方式进行赋值

​ 在进行参数默认时，必须从右到左依次连续默认

函数的声明和定义分开时，默认参数在定义和声明处都可以写，但是只能写一次。建议写在声明处。

#include <iostream>

using namespace std;

void fun(int a,int b = 1);

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

int main(void)
{
    fun(1);
    fun(1,2);
    return 0;
}

（9）函数重载

在C语言中要实现比较两个数的大小（int、float、double），就必须写三个不同函数名的函数

int compare_int(int a,int b);

float compare_float(float a,float b);

double compare_double(double a,double b);

在C++中，支持函数重载

函数重载：在同一作用域内，可以有一组相同函数名，不同参数列表（个数，类型）的函数，这组函数称为重载函数。

int compare(int a,int b);

float compare(float a,float b);

double compare(double a,double b);

函数重载的条件：

（1）函数名必须相同

（2）函数的参数个数或类型不同

（3）返回值不能作为函数重载的条件

1、const int 和int能否构成函数重载？

​ 不能，因为都无法改变实参的值

2、const int & 和int &能否构成函数重载？

​ 能，前者不能改变实参的值，而后者可以

（10）new与delete

C语言 malloc free 函数

C++ new delete 运算符

new是申请堆空间，delete是释放堆空间

1、数据类型 *变量名 = new 变量类型

	int *p1 = new int;//在堆空间申请4字节，p1指向的空间所保存的值为0
	delete p1;
	p1 = NULL;

2、数据类型 * 变量名 = new 数据类型(初始值)

	int *p2 = new int(4);//在堆空间申请4字节，p2指向的空间所保存的值为4
	delete p2;
	p2 = NULL;

3、数据类型 *变量名 = new 数据类型[]

	int *p3 = new int[5]; //在堆空间中申请20字节，p3指针指向的空间所保存的值都为0
	delete [] p3；
    p3 = NULL;

注意：new是malloc的封装，在申请堆空间的基础上还会调用类的构造函数，delele是free的封装，在释放堆空间的基础上还会调用类的析构函数。

new与delete和new[]与delete[]要配对使用.