C++基础语法学习笔记

🕗 发布于 2024-11-11 23:41 c++ 学习笔记

格式化代码快捷键，是crtl+I

开发环境安装

QT Create

官网：Index of /new_archive/qt

国内镜像地址（国外下载太慢）

中国科学技术大学 http://mirrors.ustc.edu.cn/gtproject
清华大学 https://mirrors.tuna.tsinghua.edu.cn/gt/
北京理工大学 http://mirror.bit.edu.cn/gtpreject/
中国互联网络信息中心 https://mirrors.cnnic.cn/gt/

安装QT Create

其他直接下一步。

安装好软件后创建项目：

项目创建完成。

第一个C++代码

//注释快捷键  ctrl+/
#include <iostream>   //标准输入输出流  input输入  output输出

using namespace std;  //使用标准命名空间  

//程序主入口  
int main()
{
    //cout 输出流对象 向屏幕中输入
    //<< 在c++中有一个新的定义，可以在cout后拼接输出内容
    // endl 结束输出且换行
    cout << "Hello World!" << endl;
    return 0;
}

基本数据类型

c++的数据类型分为：

基本数据类型：布尔，整数，浮点
派生类型：修饰类型，指针类型，用户定义的复合类型等

关键字	含义	说明
bool	布尔	表示是否的概念 false true 0 1
int	整数	表示计数或数量
float	单精度	近似表达实数的概念
double	双精度	近似表达实数
char	字符	代表一个ASCII码符号 -128 - 127
void	无	表示没有，或者空的概念

基本类型占用空间

sizeof(变量)或者sizeof(类型)来探测内存大小。

sizeof是关键字，不是函数。

#include <iostream>   //标准输入输出流  input输入  output输出

using namespace std;  //使用标准命名空间

//程序主入口
int main()
{
    int a=1;
    cout <<"int:"<< sizeof(a) << endl;
    short b=1;
    cout <<"short:"<< sizeof(b) << endl;
    bool c= false;
    cout << "bool:" << sizeof(c) << endl;
    float d=1.1;
    cout << "float:" << sizeof(d) << endl;
    double e=1.2;
    cout << "double:" << sizeof(e) << endl;
    char f='a';
    cout << "char:" << sizeof(f) << endl;
    long  long g=12;
    cout << "long  long:" << sizeof(g) << endl;
    return 0;
}

类型修饰符

==short==更短

==long==更长

==signed==有符号

==unsigned==无符号

如果省略了基本类型，默认为int

short = short int

unsigned = unsigned int

类型能多次修饰

long long = long long int

类型的可能取值范围

#include <limits>

std::numeric_limits<类型>::max() 或 min() 求最大值，最小值
unsigned 能表示更大的数值范围
unsigned 在移位操作时很重要

#include <iostream>   //标准输入输出流  input输入  output输出
#include <limits>

using namespace std;  //使用标准命名空间

//程序主入口
int main()
{
    //看看改类型可以取到的最大数
    unsigned long long a= std::numeric_limits<long long int>::max();
    cout << a << endl;
    return 0;
}

类型的别名

typedef 可以给类型赋予别名，与原名等价
书写更简便，尤其时复合类型时
例如：typedef long long int LL;

#include <iostream>   //标准输入输出流  input输入  output输出
#include <limits>

using namespace std;  //使用标准命名空间

typedef long long int LL;


//程序主入口
int main()
{
    //看看改类型可以取到的最大数
    LL a= std::numeric_limits<LL>::max();
    cout << a << endl;
    return 0;
}

变量及其作用域

两个重要概念：

生成期：什么时候分配内存，什么时候释放内存
作用域：在什么位置可见，什么位置不可见

全局变量

定义在函数外的变量，静态的生存期

全局变量可以初始化，可以用表达式
全局变量可以在多个函数间，多个文件间共享
全局位置不能执行非定义语句

#include <iostream>   //标准输入输出流  input输入  output输出

int a = 100;

int b = 200; //初始化
int c; 声明

//c=a+b;  //编译错误

using namespace  std;



int main()
{
    cout << c << endl;
    return 0;
}

不能在全局位置执行其他语句，只能定义

变量可以在声明时初始化，也可以只声明。
当未初始化时，变量的值是随机的，此是很多bug发源地

局部变量

函数内部定义，函数执行时存在
局部变量可以和全局同名，会产生覆盖效果

变量赋值

赋值是最常见的动作，但其意义非凡！！

#include <iostream>   //标准输入输出流  input输入  output输出

int a = 100;





using namespace  std;



int main()
{
    int a = 5, b = 8;
    a = a + b;
    b = a - b;
    a = a - b;
    cout << a << "," << b << endl;
}

交换变量

交换 a, b 变量的值

#include <iostream>   //标准输入输出流  input输入  output输出

int a = 100;





using namespace  std;



int main()
{
    int a = 5, b = 8;
    int t = a; a = b; b = t;
    cout << a << "," << b << endl;
}

大括号作用域

大括号作用域可以嵌套，实际上局部作用域就是==最外一层==大括号。
大括号作用域可以嵌套覆盖
编程习惯：尽量缩小变量的作用域。

#include <iostream>   //标准输入输出流  input输入  output输出

int a = 100;





using namespace  std;



int main()
{
    int a = 5, b = 8;
    { int t = a; a = b; b = t; }
    cout << a << "," << b << endl;
    
}

常数和常量

常数

也叫立即数，或者“字面量”，就是硬编码到程序中的那些“死”数据。

字符常数

单引号：'A','X'

有些字符无法表示，可以直接整数，或：转义字符

#include <iostream>   //标准输入输出流  input输入  output输出







using namespace  std;



int main()
{
     char a='A';
     char b=9; //TAB键
     char c=66;//B

     cout << a<<b<<c<<endl;


}

'\t' 与 9 是同等效果的
'\n' 是什么？它的 ASCII 码是多少? 可以实验确定

#include <iostream>   //标准输入输出流  input输入  output输出







using namespace  std;



int main()
{
    char a = '\n';
    int x = a;
    cout << x << endl;

}

整型常数

默认是 int，需要长整数需要加 LL

#include <iostream>   //标准输入输出流  input输入  output输出







using namespace  std;



int main()
{
    long long  int a= 365LL * 24 * 60 * 1000;//不能采用类型的原因，数太大了
    cout << a << endl;

}

十六进制表示法： 0xff, 0xBA3C
二进制与十六进制有天然对应关系：
cout << hex << x<< endl;

#include <iostream>   //标准输入输出流  input输入  output输出







using namespace  std;



int main()
{
   
    int b=255;
    cout << hex << b << endl;


}

浮点型常数

可以使用 f 或 d 尾标表示类型
可以使用科学计数法表示更大的数字
0.5e12, 3.18e-20

#include <iostream>   //标准输入输出流  input输入  output输出







using namespace  std;



int main()
{

    double d1 = 1.234;      // 默认为double
    float f1 = 1.234f;      // 加上f后缀指定为float
    long double ld1 = 1.234L; // 加上L后缀指定为long double
    cout << d1 << f1 << ld1 << endl;
}

常量

用 const 修饰的变量，它占用数据区内存，但编译器保证你不能修改它的值。
常量必须在定义时初始化
编译器的保证只是形式上的，你可以绕开编译器，强行改变其值！
常量的用处：

多个地方用到同一个常量，内存只有一份拷贝。
程序中不希望修改的量，避免“笔误”
程序中不希望出现魔法数字，这样不利于将来的变更

定义常量

在 C++ 中，有两种简单的定义常量的方式：

使用 #define 预处理器。
使用 const 关键字。

#define 预处理器

下面是使用 #define 预处理器定义常量的形式：

#define identifier value

具体请看下面的实例：

实例

#include <iostream>
using namespace std;

#define LENGTH 10
#define WIDTH  5
#define NEWLINE '\n'

int main()
{

   int area;

   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

const 关键字

您可以使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

具体请看下面的实例：

实例

#include <iostream>
using namespace std;

int main()
{
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = '\n';
   int area;

   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

请注意，把常量定义为大写字母形式，是一个很好的编程实践。

枚举类型

把一组常数符号化，比如：星期，职称等有限种类的情形

#include <iostream>
 
// 定义枚举类型
enum TrafficLight {
    RED,
    YELLOW,
    GREEN
};
 
int main() {
    TrafficLight currentLight = GREEN;
    
    // 使用枚举值
    switch (currentLight) {
        case RED:
            std::cout << "Stop!" << std::endl;
            break;
        case YELLOW:
            std::cout << "Caution!" << std::endl;
            break;
        case GREEN:
            std::cout << "Go!" << std::endl;
            break;
    }
    
    return 0;
}

可以通多 typedef 来定义enum的别名，避免定义多个变量时的尴尬。

#include <iostream>  
  
// 定义一个简单的enum class  
enum class Color {  
    RED,  
    GREEN,  
    BLUE  
};  
  
// 使用typedef为Color创建一个别名  
typedef Color ColorAlias;  
  
int main() {  
    // 使用原始enum class类型  
    Color myColor = Color::RED;  
    std::cout << "Original enum: " << static_cast<int>(myColor) << std::endl;  
  
    // 使用别名  
    ColorAlias aliasColor = ColorAlias::GREEN;  
    std::cout << "Alias enum: " << static_cast<int>(aliasColor) << std::endl;  
  
    return 0;  
}

#include <iostream>  
  
// 定义一个简单的enum  
enum Color {  
    RED,  
    GREEN,  
    BLUE  
};  
  
// 使用typedef为Color创建一个别名  
typedef Color ColorAlias;  
  
int main() {  
    // 使用原始enum类型  
    Color myColor = RED;  
    std::cout << "Original enum: " << myColor << std::endl; // 注意：这里可能不会输出整数值，取决于编译器和上下文  
  
    // 使用别名  
    ColorAlias aliasColor = GREEN;  
    std::cout << "Alias enum: " << aliasColor << std::endl; // 同样，可能不会输出整数值  
  
    // 因为是普通的enum，我们可以直接比较枚举值和整数  
    if (myColor == 0) {  
        std::cout << "My color is RED!" << std::endl;  
    }  
  
    // 使用别名进行比较也是相同的  
    if (aliasColor == Color::GREEN) {  
        std::cout << "Alias color is GREEN!" << std::endl;  
    }  
  
    return 0;  
}

类型修饰符

对大类型进行细化， short long signed unsigned
const 常量，
volatile 不要进行自动优化

存储修饰符

auto 默认的类型，称为：自动变量、栈变量、局部变量。c++17 已经把 auto 挪为他用，不再是类型修饰符
register 直接放寄存器中，速度快。c++17 开始废弃

static 修饰，静态空间，与全局变量同在
extern 跨文件的伪声明
并不分配内存，只是告诉编译器，全局变量会在另一个地方声明

#include <iostream>


using  namespace std;

int  g_a=5;

void f(){
    //也是一个静态变量，作用域只在f函数里面
    static int a=5;
}


int main() {
   
    return 0;
}

内存的类型

程序分配的内存，主要在“栈”和“堆”这两部分。“堆”比“栈”复杂

只读代码: 存代码，也包括立即数，以及定常资源
静态空间：存放static变量，全局变量，常量
栈区（stack）：自动变量，函数执行时的上下文环境
堆（heap）: 程序运行中，动态地申请及归还

堆和栈的比较

基本运算符

本质上说，运算符就是一种函数，只是表现形式更加人性化

目的概念

目就是参加运算操作数的个数

主要有单目，双目，三目（只有一个运算符）
同一运算符也可以有多目 a-b 和 -a 称为运算符的重载形式
运算符有优先级和结合律

算数运算符

加减乘除取整取余

+，-，*，/（取整），%（取余）

r变大写R

#include <iostream>


using  namespace std;


int main() {
    char x='r';
    x-=32;
    cout << x<<endl;


    return 0;
}

关系运算符

大于，等于，小于

逻辑运算符

表示：与或非的概念 && || !
注意优先级：
!a&&b的意思是： (!a) && b ，而不是: !(a&&b)
a || b && c 的意思是： a || (b && c) ，而不是： (a||b) && c
逻辑运算符有短路求值特性，当心！

其他

赋值 = 本身是个运算符，结合律：右结合
所以才有：a = b = c；意思是： a = (b = c)
( ) 是运算符，它的意思是强制转换，有可能丢失精度
如何取：天花板？地板？ 3.5 -> 3 3.5 -> 4

#include <iostream>


using  namespace std;


int main() {
    double a=3.16;
    int b=(int)a;
    cout << b<<endl;


    return 0;
}

#include <iostream>


using  namespace std;


int main() {
    double a=3.66;
    int b=(int)(a+0.5);
    cout << b<<endl;
    return 0;
}

选择与分支

根据条件的真假，决定执行哪路代码

if .. else.. switch ?: 都有这个能力
if 的条件中尽量用 bool, 其它类型会强制转为bool

if 的条件中可能会发生短路求值现象
if(a表达式 && b表达式) ...
当 a表达式为假的时候， b表达式根本不会执行
同理， if(a表达式 || b表达式) ...

#include <iostream>


using  namespace std;


int main() {
    int a = 5, b = 8;
    int x = 100;
    if(a>10 && (x=b)){
    cout << "here" << endl;
    }
    cout << x << endl;
}

单 if 语句

尽量使用这个语句，避免 else

试一试：给定年份，求是不是闰年

#include <iostream>


using  namespace std;


int main() {
    int x=2000;
    bool leap_year = x % 4 == 0 && x % 100 != 0|| x % 400 == 0;
    cout << leap_year << endl;
}

太过复杂

#include <iostream>


using  namespace std;


int main() {
    int year =2000;
    bool leap = false;

    if(year%4==0)leap=true;
    if(year%100==0)leap=false;
    if(year%400==0)leap=true;
    cout << leap << endl;
    return 0;
}

这样精简一些

if .. else

if 语句是可以嵌套的，嵌套是 bug 的发源地之一（哪个else 对应哪个if）
试一试：给定 a, b, c 三个数，求居中的一个(假设没有相等的情况)

#include <iostream>


using  namespace std;


int main() {
    int a = 5, b = 2, c = 8;
    if(a>b){
        if(b>c)
            cout << b << endl;
        else
            if(c>a) cout << a << endl;
            else cout << c << endl;
    }
    else{
        if(b<c)
            cout << b << endl;
        else
            if(c<a) cout << a << endl;
            else cout << c << endl;
    }
}

switch

当分支情况较多时，
if .. else if .... else if .... else ...
嵌套过多，维护不方便。

要求：

switch 圆括号中的值必为：整数，字符或者枚举类型

如果不满足这个要求，可以用表达式换算为符合要求。
示例：对学生成绩进行分类，输出： A, B, C, D, E 5个等级
分类标准：

#include <iostream>


using  namespace std;


int main() {
    int score = 85;
    char level = 'E';
    switch (score / 10) {
    case 9:
    case 10:
        level = 'A';
        break;
    case 8:
        level = 'B';
        break;
    case 7:
        level = 'C';
        break;
    case 6:
        level = 'D';
    }
    cout << level << endl;
}

三目运算符

xxx = a ? b : c; //重点在求值，不在分支

while循环

死循环

while(true){
执行一些动作；
}
配合的出口语句：break
示例：对学生成绩进行分类，输出： A, B, C, D, E 5个等级

#include <iostream>


using  namespace std;


int main() {
    int score =100;
    int a=score-60;
    char level = 'E';
    while(true){
        if(a<0) break;
        level--;
        a -= 10; // a = a - 10;
        if(level=='A') break; // 封顶
    }
    cout << level << endl;
}

示例：已知正整数x，从低位到高位，输出每个十进制数位

#include <iostream>


using  namespace std;


int main() {
    int a=0;
    while(true){
        cout << a%10 <<endl;
        a /= 10;
        if(a==0) break;

    }
    return 0;
}

while 和 do..while

do-while 循环并不常用，所有情况，可以用内部的break来解决

for循环

for 循环的语法：

for(初始化循环变量; 循环保持条件; 循环变量变化){
循环体
}

循环变量的生存期
循环变量仅仅在 for 语句范围内有效，是局部变量，放在栈中
循环变量的生存期，比循环体内的局部变量更长

continue 直接进入下一轮循环
if(条件) continue; 越过循环的某些轮次不做
打印九九乘法表

#include <iostream>


using  namespace std;


int main() {
    for(int j=1; j<=9; j++){
        for(int i=1; i<=j; i++){
            int k = i * j;
            cout << j << "x" << i << "=" << k <<" ";
        }
        cout << endl;
    }
    return 0;
}

100以内的素数

素数：就是不能再等分的数，比如：2，5，19.... 最小的素数是2

#include <iostream>


using  namespace std;


int main() {
    for(int i=2;i<=100;i++){
        bool flag=true;
        for(int n=2;n<=i-1;n++){
            if(i%n==0){
                flag=false;
                break;
            }
        }
        if(flag){
            cout << i << endl;
        }
    }
    return 0;
}

分解质因数

#include <iostream>


using  namespace std;


int main() {

        int num,temp;
        num=90;
        temp=num;//保护
        for(int i=2;i<=temp;i++)
        {
            while(num%i==0)
            {
                printf("%d ",i);
                num/=i;
            }
        }
        return 0;

}

函数

函数，在数学上的定义：对于输入的若干值，返回唯一的值。

#include <iostream>


using  namespace std;

int myadd(int a, int b);

int main() {
    int a=1,b=2;
    int result=myadd(a,b);
    cout  << result << endl;
    return 0;

}

int myadd(int a, int b){
    int t = a * 10 + b;
    return t;
}

原文地址：https://blog.csdn.net/rsrucdhh/article/details/138443462

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Java 中的 @NotNull、@NotEmpty 和 @NotBlank 的区别
下一篇：go语言中的log 包详解

算数基本定理@质因数分解原理
把自然数写成素数的乘积，结论就是著名的算术基本定理。此定理建立了自然数与素数之间的一个重要的关系式。算数基本定理是整除理论性质和结论的精华,是整个初等数论的基础证明一些方程是否有整数解能够从公式的角度
阅读更多2024-11-15
用 Python 从零开始创建神经网络（六）：优化（Optimization）介绍
在随机初始化的模型中，或者即使是采用更复杂方法初始化的模型中，我们的目标是随着时间的推移培训或教育一个模型。为了训练一个模型，我们调整权重和偏差以提高模型的准确性和置信度。为此，我们需要计算模型的错误
阅读更多2024-11-15
海思3403对RTSP进行目标检测
用ss928 实现rtsp流的目标检测
阅读更多2024-11-15
亮数据——助力全球数据抓取的高效代理平台
特别是在需要跨境数据采集的场景中，亮数据的全球代理池能够让用户根据目标网站的地域需求，选择不同地区的IP地址，以此提升数据抓取的稳定性和成功率。亮数据不仅提供了丰富的IP资源，还内置了智能管理系统，可
阅读更多2024-11-15
【卡尔曼滤波】递归算法Recursive的应用 C语言、Python实现（Kalman Filter）
【卡尔曼滤波】递归算法Recursive的应用 C语言、Python实现（Kalman Filter）
阅读更多2024-11-15
记一次工作中订单幂等处理方案
当然可以考虑在数据库新增一张表，这张表上有第三方订单号的字段，并为此字段建立唯一索引，每次下单前预先往这张表插入数据，如果此第三方订单号已存在，那么插入数据必然报错。第一次是通过分布式锁检测，这是在
阅读更多2024-11-15
大数据湖项目建设方案（100页WORD）
随着信息技术的飞速发展，数据量呈现出爆炸性增长的趋势。企业、政府机构及科研单位在运营过程中积累了大量的数据资源，这些数据中蕴含着巨大的价值，但如何高效地存储、处理和分析这些数据，成为了一个亟待解决的问
阅读更多2024-11-15
深度学习笔记14-卷积神经网络2
卷积神经网络，是包含卷积运算且具有深度结构的前馈神经网络。在卷积神经网络中，包含卷积层、池化层和全连接层三种重要的结构。相比前馈神经网络，卷积层和池化层是新增的网络结构，在提取特征时，卷积神经网络使用
阅读更多2024-11-15
[Mysql基础] 表的操作
1.1 语法说明：field表示列名datatype表示列的类型字符集，如果没有指定字符集，则以所在数据库的字符集为准collate校验规则，如果没有指定校验规则，则以所在数据库的校验规则为准。
阅读更多2024-11-15
Mysql-DDL语句
Mysql DDL语句的使用方法和配置命令，可以更加快速熟悉的掌握Mysql基本操作命令
阅读更多2024-11-15

C++基础语法学习笔记

格式化代码快捷键，是crtl+I

开发环境安装

第一个C++代码

基本数据类型

c++的数据类型分为：

基本类型占用空间

类型修饰符

类型的可能取值范围

类型的别名

变量及其作用域

全局变量

局部变量

变量赋值

大括号作用域

常数和常量

常数

字符常数

整型常数

浮点型常数

常量

定义常量

#define 预处理器

实例

const 关键字

实例

枚举类型

类型修饰符

存储修饰符

内存的类型

基本运算符

目的概念

算数运算符

关系运算符

逻辑运算符

其他

选择与分支

if .. else

switch

三目运算符

while循环

死循环

while 和 do..while

for循环

100以内的素数

分解质因数

函数

相关文章