初步认识C++

一、了解C++

C++是一种计算机高级程序设计语言,由C语言扩展升级而产生 ,最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。
C++既可以进行C语言的过程化程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时,还可以进行基于过程的程序设计。

  1. C++是C的增强
    (1)C++具有严格的数据类型检查
    (2)新增了命名空间
    (3)新增了异常处理
    (4)新增了面向对象编程
    (5)新增了变量的权限
    (6)新增了变量的引用
    (7)新增了函数重载及运算符重载

  2. C++里的特性及专业术语
    (1)类
    (2)对象
    (3)继承
    (4)多态
    (5)封装
    (6)组合
    (7)静态绑定
    (8)动态绑定
    (9)特征
    (10)行为

  3. C++程序的编译
    (1)预处理
    (2)编译
    (3)汇编
    (4)链接

二、内存模型与名字空间

  1. 命名空间
    声明格式:
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 int50;//开辟堆空间的同时对该空间进行初始化工作,初始化为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++初步认识的知识点总结,如有不足希望大家能指出。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值