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

C++特点及优势

（1）实现了面向对象，在高级语言中，处理运行速度是最快；

（2）非常灵活，功能非常强大，相对于C的指针优势，C++的优势为性能和类层次结构；

（3）严谨、精确和数理化........

C++和C语言的区别

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

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

标准输入输出

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

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

编译：g++ demo.cpp

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

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

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

cpp 复制代码

#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同时获取多个值

cpp 复制代码

#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

自定义命名空间

cpp 复制代码

#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对象

cpp 复制代码

#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()进行复杂的字符串格式化

cpp 复制代码

#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()相同

cpp 复制代码

#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函数，所以用此函数）

cpp 复制代码

#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;
}

引用

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

cpp 复制代码

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

特点（重点）

（1）必须进行初始化

（2）引用不能单独存在，也不能改变指向

（3）普通引用不能用常量或者临时值进行初始化

引用作为形参类型

交换a，b的值

cpp 复制代码

#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关键字（运算符）申请的内存空间是有类型的给内存初始化，返回指定类型的指针，并且可以自动计算所需大小。

申请变量

cpp 复制代码

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

申请数组

cpp 复制代码

#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）如果参数列表相同，但返回值不同是不可以重载的。

函数默认参数

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

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

cpp 复制代码

#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;
}

类的初识

栈区创建对象

cpp 复制代码

#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;
}

堆区创建对象

cpp 复制代码

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;
}