C++（标准输入输出流、命名空间、string字符串、引用）

C++特点及优势

（1）实现了面向对象，在高级语言中，处理运行速度是最快；
（2）非常灵活，功能非常强大，相对于C的指针优势，C++的优势为性能和类层次结构；
（3）严谨、精确和数理化........

C++和C语言的区别

C语言是面向过程的语言，C++是面向对象的语言。

C++兼容C语言的头文件 #include <cstdio>

标准输入输出

输出流对象（std::cout<<）

可以自动识别基本类型的输出类型

编译：g++ demo.cpp

输入流对象（std::cin>>）

自动识别基本类型的数据类型

练习：输入一个字符如果是大写则转为小写如果是小写则转为大写

#include <iostream>
int main()
{char c;std::cin >> c;if (c >= 'a' && c <= 'z'){//a = a - 32;std::cout << (char)(c - 32) << std::endl;}else if(c >= 'A' && c <= 'Z'){c += 32;std::cout << c << std::endl;}return 0;
}

cin同时获取多个值

#include <iostream>
int main(int argc, char const *argv[])
{int a;char c;std::cin >> a >> c;std::cout << a << " " << c << std::endl;return 0;
}

命名空间

避免命名空间污染，C++的标准库都是在std命名空间中定义的（所有的类和对象）。

表示方法

方式一：using namespace std;
方式二：std::cout

自定义命名空间

#include <iostream>
using namespace std;
namespace teacher
{char name[20] = "zhangsan";void showName(){cout << name << endl;}
}
namespace worker
{char name[20] = "lisi";void showName(){cout << name << endl;}
}
using namespace teacher;
using namespace worker;
int main(int argc, char const *argv[])
{//cout << name << endl;    //报错的位置cout << teacher::name << endl;cout << worker::name << endl;cout << "-----------" << endl;teacher::showName();worker::showName();return 0;
}

teacher和worker命名空间中都有name，如果不写命名空间，会出现访问不明确的错误。

C++增加bool类型

（1）bool是基本数据用来表示逻辑真假
（2）非0为真 true，0为假 false
（3）增强程序可读性 int isFull(); bool isFull();

字符串处理

（1）延续C风格，字符数组 char s[20] = "hello"; 字符指针 char *s = "hello";
（2）C++标准库中string类（string不是基本数据类型，而是类类型，对象类型）

创建string对象

#include <iostream> // iostream头文件中包含string头文件，所以可以省略
//#include <string>
using namespace std;
int main()
{string s1 = "hello world";string s2("hello s2");string s3(s2); // s3是用s2复制的string类型对象string s4 = s1; //string对象复制可以通过赋值符号=，直接将值赋予目标对象	cout << "s1:" << s1 << endl;cout << "s2:" << s2 << endl;cout << "s3:" << s3 << endl;cout << "s4:" << s4 << endl;return 0;
}

字符串拼接和比较

string只能拼接string，拼接其他类型需要使用sprintf()进行复杂的字符串格式化

#include <iostream>
#include <string>
using namespace std;
int main()
{string s1 = "hello";string s2 = "world";s1 += s2;//把s2的字符串追加到s1后面cout<<s1<<endl;//s1 += 1;//错误 string类型的拼接，只能拼接string类型或者C风格字符串char buf[100];sprintf(buf,"%s%d",s1.c_str(),1);//c_str()：string类型或者C风格字符串cout<<buf<<endl;//字符串比较cout<<(s1 == s2)<<endl; // 比较的是第一个不相等的ASCII码值cout<<(s1 != s2)<<endl;return 0;
}

empty和size函数

empty()判断空，如果字符转为空，返回true；否则，返回false
size()返回字符串长度，和strlen()相同

#include <iostream>
using namespace std;
int main()
{string s1 = " ";cout << s1.empty() << endl;string s2 = "";cout << s2.empty() << endl;string s3 = "hello world";cout << s3.size() << endl;return 0;
}

cin和getline函数输入字符串

cin遇到空格结束
getline函数，输入字符串遇到'\n'结束输入（C++中无法使用gets函数，所以用此函数）

#include <iostream>
using namespace std;
int main()
{string s1;cout << "please input s1" << endl;// 参数1：cin输入流获取字符串，参数2：读取到的字符串存放为止getline(cin,s1);cout << "getine s1:" << s1 << endl;string s2;cout << "please input s2" << endl;cin >> s2;cout << "cin s2:" << s2 << endl;return 0;
}

引用

引用的本质就是给变量起别名。

#include <iostream>
using namespace std;
int main()
{int a = 10;int& b = a;return 0;
}

特点（重点）

（1）必须进行初始化
（2）引用不能单独存在，也不能改变指向
（3）普通引用不能用常量或者临时值进行初始化

引用作为形参类型

交换a，b的值

#include <iostream>
using namespace std;
void swap(int& x,int& y)
{int temp;temp = x;x = y;y = temp;
}
int main()
{int a = 10,b = 20;swap(a,b);cout << a << " " << b << endl;return 0;
}

引用作为返回值

引用作为返回值，是返回变量本身，而不是一个临时的值，要保证变量的生命周期足够长。

const修饰的引用（常引用）

指针的引用和数组的引用

引用和指针的区别（重点）

（1）不存在空的引用，引用必须连接到一块合法的内存；指针可以是空指针。
（2）引用被初始化为一个对象，就不能被指向到另一个对象；
指针可以在任何时候指向到另一个对象。
（3）引用必须在创建时被初始化；指针可以在任何时间被赋值。

动态内存分配

（1）堆区：自定义生命周期（只申请不释放堆区内存，会内存泄漏）
（2）栈区：作用域结束，变量才释放
（3）静态变量：程序结束才释放

动态内存的申请和释放

new和delete
C++中new关键字（运算符）申请的内存空间是有类型的给内存初始化，返回指定类型的指针，并且可以自动计算所需大小。

申请变量

#include <iostream>
using namespace std;
int main()
{int* p = new int; // 指针变量p指向，在堆区申请一个int类型的内存*p = 10;delete p; // 释放new在堆区申请int类型空间p = NULL;return 0;
}

申请数组

#include <iostream>
using namespace std;
int main()
{int* p = new int[10]; // 在堆区申请一个int类型的10个元素的数组delete[] p; // 释放数组p = NULL;return 0;
}

释放指针置空

delete释放的是指针指向的内存，指针是一个变量，只有在程序结束时才被销毁。释放了内存空间后，原来指向这块空间的指针还是存在，只不过现在指针指向的内容垃圾区域，所以释放内存后把指针指向NULL，防止指针在后面不小心又被解引用。

new和malloc的区别（重点）

（1）malloc是库函数；new是关键字（运算符）
（2）malloc申请的空间没有类型（void *），需要强转；new申请的直接初始化
（3）new会调用构造函数

函数延伸

重载

英文叫做overload，C++中允许创建多个名称相同的函数，需要满足：
（1）在同一作用域内，函数名相同，形参列表不同（类型或者个数不同），返回值不作为决定性条件；
（2）如果参数列表相同，但返回值不同是不可以重载的。

函数默认参数

正常来说函数调用时，形参从实参获取值，但是还可以给形参一个默认值，这样形参就不必从实参取值了（一旦某个形参被赋予了默认值，那么其后面的所有形参都必须有默认值）。

当函数的声明和定义分开写时，只能在声明的部分写默认参数

#include <iostream>
using namespace std;
void fun(int a = 10, int b = 20, int c = 30);
int main()
{fun();fun(1);return 0;
}
void fun(int a, int b, int c)
{cout << a << b << c <<endl;
}

类的初识

栈区创建对象

#include <iostream>
using namespace std;
class Student
{
public:string name;int age;void set(string n, int a){name = n;age = a;}
};
int main(int argc, char *argv[])
{Student s; //栈区实例化对象//直接对成员变量赋值s.name = "zhangsan";s.age = 18;//调用成员函数间接赋值s.set("lisi",20);return 0;
}

堆区创建对象

int main(int argc, char *argv[])
{Student *s = new Student() ; //在堆区创建一个Student类型对象//直接对成员变量赋值s->name = "zhangsan";s->age = 18;//调用成员函数间接赋值s->set("lisi",20);delete s;s = NULL;return 0;
}