一、了解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++初步认识的知识点总结,如有不足希望大家能指出。