一、了解C++
C++是一种计算机高级程序设计语言，由C语言扩展升级而产生 ，最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。
C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计。
-
C++是C的增强
（1）C++具有严格的数据类型检查
（2）新增了命名空间
（3）新增了异常处理
（4）新增了面向对象编程
（5）新增了变量的权限
（6）新增了变量的引用
（7）新增了函数重载及运算符重载 -
C++里的特性及专业术语
（1）类
（2）对象
（3）继承
（4）多态
（5）封装
（6）组合
（7）静态绑定
（8）动态绑定
（9）特征
（10）行为 -
C++程序的编译
（1）预处理
（2）编译
（3）汇编
（4）链接
二、内存模型与名字空间
- 命名空间
声明格式：
namespace 标识符名称
{
// 代码块
}
访问格式1：命名空间的名称 ：： 需要访问的内容
访问格式2：using 命名空间的名称 ：： 需要访问的内容
访问格式3：using namespace 命名空间名称
例如：
namespace zhang
{
int a;
}
zhang :: a;//访问格式1：
using zhang :: a;//访问格式2：
using namespace zhang;//访问格式3：
//如果后面用到a就是用到的命名空间里的a
注：
（1）命名空间是可以发生嵌套。
（2）命名空间可以分为有名的命名空间和无名的命名空间。
（3）命名空间是属于全局的一部分，只不过是取了全局的一块区域命了一个名称而已。
（4）访问命名空间的时候需要用到域作用符号。
2.作用域
（1）局部作用域
在函数体内{}、代码块{}、for（）循环、while（）循环里等等的区域，称之为局部作用域，如果变量声明或者定义在局部作用域内，那么它的生命周期只在变量声明的开始一直到函数体结束。
（2）全局作用域
除局部作用域以外的区域都可以认为是全局作用的区域，那么如果变量声明或者是定义在全局作用域，那么它的生命周期是整个文件。
3.动态内存
程序在运行时才分配的空间，称之为动态内存。例如，在C语言里，可以用malloc和free两个函数，来动态的开辟堆区空间和释放堆区空间；C++提供了new和delete操作符来操作堆区空间的开辟和释放。
new：用于开辟堆区空间，相当于是C里的malloc。
delete：用于释放堆区空间，相当于是C里的free。
（1）开辟变量地址空间
声明格式：
数据类型 * 标识符名称 = new 数据类型;//在堆区开辟变量地址空间，用标识符名称来指向堆区空间，堆区空间的大小就是数据类型的大小
数据类型 * 标识符名称 = new 数据类型（初始值）;//在堆区开辟变量地址空间，同时存放初始值
例如：
int * p = new int;//在堆区开辟int类型大小的空间，并且用p指向该空间
int * q = new int （50）;//开辟堆空间的同时对该空间进行初始化工作，初始化为50
delete p;//释放变量地址空间
delete q;
（2）开辟数组地址空间
声明格式：
数据类型 * 标识符名称 = new 数据类型[数组大小];//在堆区开辟变量地址空间，同时指定数组的大小
例如：
int *q = new int[10] ;//在堆区开辟一个具有10个元素的数组空间
int *p = new int[5]{1,2,3,4,5} ;//在堆区开辟一个具有5个元素的数组空间,并且初始值
delete [] q ;//释放
delete [] p ;
三、类和对象
1.类
概念：是用来描述现实世界中的事物。
声明格式：
class 类名（标识符名称）
{
//特征
//行为
};
例如：
class People
{
public:
//特征
const char * name;//name用于描述姓名
int age;//age用于描述年龄
const char * sex;//sex用于描述性别
//行为
void eat()
{
cout << "吃饭" << endl;
}
void sleep()
{
cout << "睡觉" << endl;
}
void walk()
{
cout << "走路" << endl;
}
};
2.对象
概念：对类的实例化。
对象实例化格式：
（1）在栈区实例化
声明格式：
类名 对象名（标识符名称）；
例如：
People zhangsan;
访问格式：
对象名.成员;
例如：
zhangsan.eat();//访问People里的eat方法
（2）在堆区实例化
声明格式：
类名 * 对象名 = new 类名;
例如：
People * lisi = new People;
访问格式：
对象名->成员;
例如：
lisi->sleep();//访问People里的eat方法
完整代码：
#include <iostream>
using namespace std;
//用类描述
class People
{
public:
//特征
const char* name;//name用于描述姓名
int age;//age用于描述年龄
const char* sex;//sex用于描述性别
//行为
void eat()
{
cout << "吃饭" << endl;
}
void sleep()
{
cout << "睡觉" << endl;
}
void walk()
{
cout << "走路" << endl;
}
};
int main()
{
//实例化people类为具体的对象
//在栈区实例化
People zhangsan;//zhangsan具备了people的特征和行为
zhangsan.name = "张三";
cout << "姓名:" << zhangsan.name << endl;
zhangsan.age = 20;
cout << "年龄:" << zhangsan.age << endl;
zhangsan.sex = "男";
cout << "性别:" << zhangsan.sex << endl;
zhangsan.eat();//栈区用 .
//在堆区实例化
People* lisi = new People;//lisi也具备了people的特征和行为
lisi->name = "李四";
cout << "姓名:" << lisi->name << endl;
lisi->age = 18;
cout << "年龄:" << lisi->age << endl;
lisi->sex = "女";
cout << "性别:" << lisi->sex << endl;
lisi->sleep();//堆区用 ->
return 0;
}
3.访问修饰符
为了保护类的成员，C++提供了三种类的成员访问修饰符：public（公共）、private（私有）、protected（受保护）。
（1）public（公共）
用户把变量或者是函数放置在类的public下，那么这些变量和函数就具有公共的属性。
1）在public下的成员对于整个类都是可见的。
2）在public下的成员对于类体外也是可见的。
3）在public下的成员对于友元函数也是可见的。
4）在public下的成员对于派生类（子类）也是可见的。
（2）private（私有）
用户把变量或者是函数放置在类的private下，那么这些变量和函数就具有私有属性。
1）在private下的成员对于整个类都是可见的。
2）在private下的成员对于类的外部是不可见的。
3）在private下的成员对于友元函数是可见的。
4）在private下的成员对于派生类（子类）是不可见的。
（3）protected（受保护）
用户把变量或者是函数放置在类的protected下，那么这些变量和函数就具有保护属性。
1）在protected下的成员对于整个类都是可见的。
2）在protected下的成员对于类的外部是不可见的。
3）在protected下的成员对于友元函数是可见的。
4）在protected下的成员对于派生类（子类）是可见的。
#include <iostream>
using namespace std;
class Test
{
public://公共
int a = 50;
void function()
{
cout << "a=" << a << endl;
cout << "这是public" << endl;
}
private://私有
void function1()
{
cout << "这是private" << endl;
}
protected://受保护
void function2()
{
cout << "这是protected" << endl;
}
};
int main()
{
Test test;
test.function();
cout << "test.a=" << test.a << endl;
return 0;
}
注：
（1）如果在类里面没有写任何的类的成员访问修饰符，那么该类下的成员都是归于private属性下。
（2）一般将成员变量放置到private属性下。
4.构造函数
概念：构造函数是一种特殊的函数，它实质还是称为函数，如果用户没有显示的书写构造函数，那么编译器会帮用户自动的生成了一个默认的构造函数。
作用：为了初始化类的成员变量。
声明格式：
类名（参数）;
{
//代码块
}
例如：
class Test
{
public:
const char * name;
int age;
const char * sex;
Test()
{
name ="zhangsan";//初始化
age = 18;
sex = "nan";
cout << "这是构造函数" << endl;
}
/* Test() : name("lisi"), age(20), sex("nv");
{
cout << "这是构造函数" << endl;
}
*/
调用构造函数：
（1）显示调用
声明格式：
类名 对象名（构造函数参数列表）;//这时候就显示的调用类的构造函数
例如：
#include <iostream>
using namespace std;
class Test
{
public:
const char* name;
int age;
const char* sex;
Test()
{
name = "zhangsan";//初始化
age = 18;
sex = "nan";
cout << "这是构造函数" << endl;
}
};
int main()
{
Test test;//显示调用
return 0;
}
（2）隐式调用
声明格式：
类名（构造函数参数列表）;//隐式的调用类的构造函数
5.析构函数
概念：析构函数是一种特殊的函数，它实质也是函数，如果用户没有显示的书写析构函数，那么编译器会自动帮用户生成一个默认的隐藏的析构函数。
作用：用来释放空间的。
声明格式：
~类名（）
{
//代码块
}
析构函数的调用时机：
（1）当类的对象使用完成之后，会调用一次析构函数。
（2）当类的指针对象被销毁的时候，会调用一次析构函数。
（3）当main函数体结束时会调用析构函数 。
注：
（1）析构函数不能带参数.
（2）类体里面只允许有一个析构函数。
（3）析构函数前没有返回值。
6.拷贝构造函数
概念：如果用户需要用一个对象去初始化另外一个对象的时候，就会用到拷贝构造函数，其实质就是一个构造函数，如果用户没有显示的将拷贝构造函数写出来，那么编译器会自动的生成一个默认的隐藏的拷贝构造函数。
声明格式：
类名（const 类名 & obj）
{
//代码块
}
7.this指针
概念：它是一种特殊的指针，它是存在于类的普通成员函数里，C++提供this指针的目的是为了解决二义性问题，并且它是隐式的指针，它是指向当前类。
使用格式：
this -> 成员;
注：
静态成员函数和友元函数中没有this指针。
8.static
概念：用static声明函数或变量，函数或变量是静态的。
（1）静态成员函数
声明格式：
static 返回值类型 函数名（参数列表）
{
//函数体
}
访问格式：
//通过类的对象访问类的静态成员
对象名.静态成员;
对象名->静态成员;
//通过类加上域作用符号来访问类的静态成员
类名 ：：静态成员;
注：
1）静态成员函数里没有this指针
2）静态成员函数不能访问类的非静态成员
3）类的非静态成员函数可以访问类的静态成员
（2）静态成员变量
声明格式：
static 数据类型 变量名;
注：
在类里面不能对类的静态成员变量进行初始化，需要在类外对静态成员变量进行初始化
类外初始化的格式：
数据类型 类名 ：：静态成员变量名 = 初始值;
9.const
（1）const修饰成员变量
作用：变为常量，不能改变。
声明格式：
const int a; //可以在声明a的时候不用进行初始化， 那么必须在构造函数初始化列表中进行初始化
（2）const修饰的成员函数
作用：用const修饰的成员函数中不能去更改类的成员变量的值（即const修饰的成员函数里对类的成员变量是一个只读的行为）
声明格式：
返回值类型 函数名 （参数列表）const
{
//函数体
}
10.友元
作用：给类的外部提供一个访问类的私有成员的接口
（1）友元函数
概念：C++提供了友元函数就可以通过友元函数访问到类的私有成员，C++规定是友元函数声明在类里，就表示该函数是该类的友元，那么就可以通过友元函数访问类的私有成员，友元函数的定义放置在类的外部。
声明格式（在类里声明）：
friend 返回值类型 函数名（参数列表）;//友元函数的声明
访问格式（在类外定义）：
返回值类型 函数名（参数列表）
{
//函数体
}
注意：
1）友元函数虽然声明放置在类的内部，但是它不属于类的成员函数。
2）友元函数没有this指针。
3）给类的外部提供一个访问类的私有属性成员的接口。
（2）友元类
概念：C++提供了友元类就可以通过友元类访问类的私有成员，C++规定是友元类声明在一个其他类里，就表示该友元类是其他类的友元，那么就可以通过友元类访问其他类的私有成员，友元类的定义放置在其他类的外部。
声明格式（在类里声明）：
friend class 类名；//声明了一个友元类
访问格式（在其他类外定义）：
class Test
{
//类体
}
四、标准的输入和输出流
1.输入和输出流
（1）输入流
概念：就是数据从输入设备（键盘、鼠标、磁盘等等）流向内存的过程，称之为“输入流”，为了不与输出流相冲突，编译器在内存开辟了一个缓冲区，该缓冲区用于存放数据。
（2）输出流
概念：数据从内存流向输出设备（终端显示器、控制台等等）的过程，称之为“输出流”，为了不与输入流相冲突，编译器在内存开辟了一个缓冲区，该缓冲区用于存放数据
2.标准的输入和输出流类：iostream类
（1）cout：标准的输出
格式：
cout << 基本的数据类型;
符号：<<(输出符号)
（2）cin：标准的输入
格式：
cin >> 基本类型的变量;
符号：>>（输入符号）
五、总结
以上就是我对C++初步认识的知识点总结，如有不足希望大家能指出。
1006
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
