C++基础语法

已于 2023-10-14 09:22:19 修改
阅读量273 收藏
点赞数 5
文章标签： c++ 开发语言
于 2023-10-11 19:32:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_48219942/article/details/133777081
版权

C++是一门面向过程、面向对象和泛型编程的高级编程语言。

目录标题

C++基础语法大纲

  • 头文件、库文件和项目文件的关系
    • 头文件
    • 库文件
    • 项目文件
    • 关系
  • 数据类型
    • 基本数据类型
      • 整型
      • 字符型
      • 浮点型
      • 布尔型
    • 复合数据类型
      • 数组
      • 字符串
      • 结构类型
      • 共用体
      • 枚举
      • 指针
  • 运算符
    • 算术运算符
    • 关系运算符
    • 逻辑运算符
    • 位操作运算符
    • 赋值运算符
  • 循环控制语句
    • while循环
    • for循环
    • do…while循环
  • 分支控制语句
    • if分支语句
    • switch选择语句
  • 内存管理
    • 代码区
    • 全局区
    • 栈区
    • 堆区
  • 类
    • 类的性质
      • 抽象
      • 封装
      • 多态
      • 继承
    • 构造函数
      • 默认和自定义构造函数
      • 默认和自定义拷贝构造函数
    • 析构函数
    • 类的继承
  • 模版
    • 模版类
    • 模版函数
    • STL库

在这里插入图片描述

1 头文件、库文件和项目文件的关系

  • 头文件：头文件包含了变量声明、函数声明、类声明等信息，头文件不包涵函数定义。
    • 头文件的防御式定义如下：
#ifndef __HEADFILE__
#define
...
...
#endef

// 头文件的一般引用
#include<iostream>
#include<cmath>

  • 库文件：包括编译器自带的库，如输入输出库及数学运算等库，还有个人及企业创建库。

  • 项目文件：是用户编写的代码源文件（通常是.cpp后缀文件）

  • 关系：通常项目文件最大，头文件不能和项目文件在同一个文件夹。

2 数据类型

2.1 基本数据类型

  • 整形数据：表示整数，如10,39,444，-778等数，有short、int、long、long long型。

    • short短型:一般分配两个字节。
    • int整型:分配4个字节。
    • long长整型:分配8个字节。
    • long long:8个以上的字节。

  • 字符型数据：系统会分配一个字节来存储字符数据，服从[[ASCII编码]]。

  • 浮点型数据：表示小数，如3.22、-44,88、0.0003等小数，有float、double、long double

    • float浮点型：通常32位。
    • double双精度型：为64位。
    • long double:一般是80或96为数据。
    • 浮点型数据的一般表示：如0.0034表示为0.34E-2，或4,30000.0表示为4.3e+5,其中不区分大小E。

  • 布尔型数据：其为逻辑数据，只有二值为真和假，通常表示成0（假）和1（真）。

2.2 复合数据类型

  • 数组：用来储存同一种数据类型的数据格式，基本数据类型都能被数组存储。
    • 一维数组：
// 创建及初始化数组
int a[5];
a[5] = {3, 5 ,}; // 创建后初始化
double b[] = {4, 66, 99}; // 创建时初始化，可以不指定数组元素数量
// 数组的索引,直接用下标来索引
c = a[3];
*a == a[0] && *(a + 1) == a[1];// 用指针来索引
  • 字符串型：使用字符串型数据要在源文件中加入string.h头文件。
// 创建字符串型变量
// include<cstring>
string str = "string"
// 可以向数组那样索引单个字符
str[0] == "s";
// 比用数组来存储字符串方便
str[] = "string";
  • 结构型：用来存储多种数据类型的数据格式，一个变量可以同时存储多种数据。
// 创建结构型数据类型
struct a
{
	int b;
	float c[];
	bool d;
}
// 定义及初始化结构型变量
a struct_date =
{
	3,
	{3, 4},
	false
};
// 结构型数据的访问
struct_date.b == 3; #使用直接成员运算符.进行访问数据。
  • 共用体型：可以存储多种数据类型，但只能存储其中的一种数据类型变量。
// 使用关键字union创建共用体类型
union union_type
{
	int int_val;
	float float_val;
	bool bool_val;
};
// 定义并初始化共用体类型变量
union_type a = 33; // 该变量为整型数据
union_type b = 4.4; // 为浮点型数据
  • 枚举型：用来创建符号常量的一种方式，有const定义的常量一样。他还可以创建枚举类型。
// 创建符号常量
// 其中Spring到Green分别表示0—5常量
enum {Sprng, Summer, Winter, Red, Green};

// 使用关键字enum定义枚举类型
enum enum_type{blue, cat = 3, dog ,};
//定义枚举变量
enum_type a = blue; #表示a的值为0
enum_type b = dog; #表示b的值为4
// 注意枚举变量的值一定是整型数据
  • 指针：用来存储其他变量存储地址的数据类型。
// 创建指针变量
int *p;
int a = 1;
p = &a; #p为指向整型的指针变量，&为取地址运算符
// 用解析运算符来*来调用指针所指的变量
*p == a;

3 运算符

C++中的运算符是用于执行各种操作的特殊符号或关键字。C++提供了多种类型的运算符，用于进行算术运算、逻辑运算、关系运算、赋值等各种操作。以下是一些常见的C++运算符的分类和示例：

运算符类型运算符示例描述
算术运算符+a + b加法
-a - b减法
*a * b乘法
/a / b除法
%a % b取余
//a // b取整
**a ** b乘幂
关系运算符==a == b等于
!=a != b不等于
>a > b大于
<a < b小于
>=a >= b大于等于
<=a <= b小于等于
逻辑运算符&&cond1 && cond2逻辑与
||cond1 || cond2逻辑或
!!cond逻辑非
位运算符&a & b按位与
|a | b按位或
^a ^ b按位异或
~~a按位取反
<<a << b左移位
>>a >> b右移位
赋值运算符=a = b赋值
+=a += b加法赋值
-=a -= b减法赋值
*=a *= b乘法赋值

4 循环控制语句

  • while语句：
while(bool_date)
{
	#循环体
	...
	...
} // bool_date为真则执行循环体，为假则不执行
  • for语句：
for(int i = 0; i > 9; i ++)
{
	// 循环体
}

// 如果循环体只是一条语句，则可以不用花括号
for(int i = 0; i > 9; i ++) cout << i;

// for语句还可以进行嵌套
for(int i = 0; i > 9; i ++)
{
	for(int j = 0; j > 9; i ++)
	{
		// 循环体
	}
	//...
}

// 条件运算符 ？ ： （是三目运算符）
i > 3; cout << i: cout << i + 1;
  • do…while语句：
// 先执行，再判断
do
{
	// 循环体
}while(bool_date)

5 分支控制语句

  • if条件语句：
//简单条件语句
if(bool_date)
{
	// 执行语句
}

// 复合条件语句
if(bool_date)
{
	// 执行语句
}
else
{
	// 执行语句
}

// 多条件语句
if(bool_date)
{

}
elif(bool_date)
{
	
}#可以更多条件判断

// 条件嵌套语句
if(bool_date)
{
	if(bool_date)
	{
		// 执行体
	}
	//执行体
}
  • switch语句：

switch语句是C++中的一种条件控制语句，用于根据表达式的值选择不同的执行路径。switch语句通常用于多个条件分支的情况，其中每个条件分支都与一个特定的值相关联。以下是switch语句的基本语法和用法：

switch (expression) {
    case value1:
        // 当expression等于value1时执行这里的代码
        break; // 可选的，用于退出switch语句

    case value2:
        // 当expression等于value2时执行这里的代码
        break;

    // 更多case分支...

    default:
        // 当expression与任何case的值都不匹配时执行这里的代码
        // 默认分支是可选的
        break;
}

switch语句的关键部分包括：

  • expression：一个表达式，它的值将用于匹配case分支。

  • case：关键字，后面跟着一个常量表达式（通常是整数、字符或枚举值），用于指定可能的值。

  • break：可选的关键字，用于终止switch语句的执行。如果没有break，程序将继续执行下一个case分支。

  • default：可选的default分支，用于处理expression不匹配任何case值的情况。

switch语句的执行流程如下：

  1. expression的值被计算。

  2. expression的值与每个case分支的值逐一比较，如果找到匹配的case，则执行相应的代码块。

  3. 如果在case分支中遇到break语句，程序将跳出switch语句，继续执行后续代码。

  4. 如果没有break语句，程序将继续执行下一个case分支，直到遇到break或switch结束。

  5. 如果没有匹配的case值，将执行default分支（如果存在），否则，switch语句将不执行任何操作。

6 内存管理

C++中的存储是按字节存储的，每个字节有8位且都有自己的虚拟地址编号，内存空间可划为代码区、全局/静态存储区、栈区和堆区==。

  • 代码区：用来存储可执行文件（也就是程序）的机器指令，通常是只读的。

  • 全局/静态存储区：一般用来存储全局变量和局部静态变量，其生命周期和程序执行的周期一样。

include<iostream>
double a; // 全部变量
int main()
{
	static int b; //局部静态变量
	reteurn 0;
}
  • 栈区（stack）：
    • 栈是一种有限的内存区域，用于存储局部变量、函数参数、函数调用信息等。
    • 栈的分配和释放内存是自动管理的，遵循==“先进后出”（LIFO）==的原则。
    • 局部变量的生命周期与其所在函数的执行范围相关。
    • 栈内存通常较小，适用于存储相对较小的数据。
int cat()
{
	float a; //局部变量
}
  • 堆区（heap）：
    • 堆内存通常比栈内存更大，适用于动态分配对象和数据。
    • 堆是内存分配给用户自定义的区别，通常使用new和delete来创建该区的数据。
    • 堆区的数据内存建立和释放是由用户管理的，一般使用new后一定要跟着delete来释放内存，以防内存泄漏。
int *a = new int(3); // 动态分配及初始化变量
float *b = new float; // 可以不初始化

int *c = new int[4]; //动态分配建立数组，数组头地址存在指针变量c中
c[0] = 22, c[1] = 33; //初始化数组

class Person{
	private:
	public:
}; // 记得加分号
Person *d = new Person; //动态分配对象
// 用完动态分配的数据后记得释放器内存，注意数组的释放格式
delete a, delete b, delete[] c; delete d;

7 类

C++中的类是一种用户自定义的数据类型，它用于表示对象的抽象概念。类是面向对象编程（OOP）的基本构建块之一，允许将数据（成员变量）和操作数据的方法（成员函数）封装到一个单独的单元中。

类的抽象及封装

  • 类的声明与定义:类是数据和方法（或属性和行为的结合体），其中有private、public和protected三个区。
// 类的声明
class Classname{
	private: // 私有成员数据创建
	int a;
	double b;
	
	public: // 公有数据及成员函数创建
	void cat(int x, float y);
	Classname(int x, double y); // 有参构造函数
	Classname(); //无参构造函数
	Classname(Classname &p); // 拷贝构造函数
	~Classname() //析构函数创建

	protected: // 保护数据，只有类及其继承类的对象才能访问
	int c;
	float d[];
}

// 类的定义
// 使用作用域解析运算符：：
void Classname::cat(int x, float y){
	x = 3;
	y = 4.4;
}
// 自定义有参构造函数，并使用列表初始化
Classname::Classname(int x, double y) : a(x), b(y){
	// ...
}
// 无参构造函数
Classname::Classname()
{
	int *p = new int(4);
}
// 拷贝构造函数
Classname::Classname(Classname &p)
{
	a = p.a;
	b = p.b;
}
// 自定义析构函数
Classname::~Classname()
{
	delete p;
}
  • 类的对象创建:
// 用include包含类所在的头文件
Classname dog(3, 4.5); // 括号定义初始化，一般用这种方式
Classname cat = Classname(4, 6.66); // 显示初始化
Classname rat{22, 4.4}; // 隐式初始化
Classname rabbit(dog); // 拷贝
  • 构造函数：有默认构造函数、有参和无参自定义构造函数及默认和自定义拷贝函数。

如果没有自定义构造函数，系统会创建默认构造函数和默认析构函数。如果定义了拷贝构造函数，也要跟着定义构造函数。

  • 析构函数：在类的对象结束前调用，用来释放动态分配的内存。

类的继承

类的继承是面向对象编程（OOP）中的一个重要概念，它允许你创建一个新类（称为子类或派生类），从一个现有的类（称为父类或基类）继承其属性和方法。继承是代码重用的一种方式，它允许你在不重新编写已有代码的情况下扩展和定制现有类。类的继承分为公有继承和私有继承。

  • 公有继承：
// 基类（父类）
class Animal {
public:
    Animal(const std::string& name) : name(name) {}

    void eat() {
        std::cout << name << " is eating." << std::endl;
    }

    void sleep() {
        std::cout << name << " is sleeping." << std::endl;
    }

private:
    std::string name;
};

// 派生类（子类）
class Dog : public Animal {
public:
    Dog(const std::string& name, const std::string& breed)
        : Animal(name), breed(breed) {}

    void bark() {
        std::cout << "Woof! Woof!" << std::endl;
    }

private:
    std::string breed;
};

//子类的对象定义及使用
int main() {
    Dog myDog("Buddy", "Golden Retriever");

    myDog.eat();    // 调用从基类继承的方法
    myDog.sleep();  // 调用从基类继承的方法
    myDog.bark();   // 调用子类自己的方法

    return 0;
}
  • 私有继承：

8 模版

未完

Thank_Dan
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值