#c数组#
本文根据文章
https://www.codersrc.com/archives/8331.html
数组 所谓数组，是有序的元素序列。 如将有限个类型相同的变量的集合命名，那么这个名称就是数组名。 数组是用于存储多个相同类型数据的集合。 通常用Array表示，也称之为线性表。
#数组 内存溢出#
溢出意思就是 算术值得长度超出显示范围
原因 比如一个计时器 最大计时100second 你让他跑了 120second
越界访问 只对存储的访问不在预先指定那个的界限内
原因 假如你申请了100字节得内存 你写到101 字节去了 越界就崩溃
c语言格式控制符/占位符
https://www.runoob.com/cplusplus/cpp-modifier-types.html
| const | const 定义常量，表示该变量的值不能被修改。 |
| volatile | 修饰符 volatile 告诉该变量的值可能会被程序以外的因素改变，如硬件或其他线程。。 |
| restrict | 由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。 |
| mutable | 表示类中的成员变量可以在 const 成员函数中被修改。 |
| static | 用于定义静态变量，表示该变量的作用域仅限于当前文件或当前函数内，不会被其他文件或函数访问。 |
| register | 用于定义寄存器变量，表示该变量被频繁使用，可以存储在CPU的寄存器中，以提高程序的运行效率 |
| \\ | \ 字符 |
| \' | ' 字符 |
| \" | " 字符 |
| \? | ? 字符 |
| \a | 警报铃声 |
| \b | 退格键 |
| \f | 换页符 |
| \n | 换行符 |
| \r | 回车 |
| \t | 水平制表符 |
| \v | 垂直制表符 |
| \ooo | 一到三位的八进制数 |
| \xhh . . . | 一个或多个数字的十六进制数 |
- %d：用来输出有符号的十进制整数（包括 int / char 类型）
- %u：用来输出无符号的十进制整数（包括 int / char 类型）
- %o：用来输出无符号的八进制整数
- %x：用来输出无符号的十六进制整数
- %c：用来输出单个字符
- %s：用来输出一个字符串
- %f：用来输出小数形式的十进制浮点数（输入时小数形式和指数形式都可以识别）
- %e：用来输出指数形式的十进制浮点数（输入时小数形式和指数形式都可以识别）
- %g：用来输出指数形式和小数形式两者中较短的十进制浮点数（输入时小数形式和指数形式都可以识别
- %p 专门用来打印 指针取出来的变量地址
- %lf 是输出指数double 类型的浮点数
-
#include <stdio.h> #include <stdlib.h> #include<string.h> int main() { int arr[10] = { 0 }; int *p = arr; char* pc = arr; printf("%p\n", p); // printf("%p\n", p+4); printf("%p\n", pc); printf("%p\n", pc + 5); printf("%p\n", p); /* 000000955EBDF558 在这里p 和pc 一样的 p pc+1不一样 000000955EBDF55C 因为char是一个字符 1 int是整形p+整形 000000955EBDF558 在内中是这样的p + 0001 pc+1 在内存 000000955EBDF559 是 pc + 01 一个字符 000000955EBDF558*/ return 0; } - %if 是打印float 类型
#字符#
字符 /t是转移字符 \n换行转移符号
———— 操作符 ————
函数调用操作符
()内的内容就是函数调用操作符
[]
逗号表达式 从左到右以此计算 真个表达式的结果 是最后一个表达式的结果。
exp1, exp2, exp3, exp....n
#include <stdio.h> int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; printf("%d\n", arr[5]); return 0; }
条件操作符(三木操作符） exp ? exp2 : exp3
#include <stdio.h> int main() { int a = 0; int b = 3; int max = 0; if (a > b) max = a; else max = b; max = a > b ? a : b; return 0; }//java 的操作符 和c的区别在于 java 是强语言必须加上 类型 int x = 10; int y = 15; int max = (x > y) ? x : y;
逻辑运算符
&& 逻辑操作符又叫比较操作符
#include <stdio.h> int main() { int x = 20; int a = 12; int b = 13; if ( x > a && b > x ) { // 这里不会执行 有一个不满足条件 printf("这是一个演示 && 满足所有条件才执行"); } return 0; }|| 逻辑符 在下列中有一个为真表达式都可以成立
#include <stdio.h> int main() { int x = 20; int a = 12; int b = 13; if ( x < a && b > 1) { //随便那个条件满足都可以执行 printf("这是一个演示 || 满足一个条件就行都可以执行"); } return 0; }
单目操作符
^ 异或运算 (不同则1 相同则0)
~ 按位取反（二进制取反 0变成1 1变成0）
！逻辑取反（真变成假 假变成真）
& 取地址
&符号是一个单目运算符，它需要放在一个变量或者值的前面。当你给出一个变量时，&返回该变量的内存地址，就像是这个变量在内存中的位置。这个被称为“取地址运算符”，因为它提供了变量在内存中的地址。int num = 42; int *ptr = #在这里，
ptr将包含num变量的地址。现在，ptr指向了num的内存位置，你可以通过ptr来访问和操作num的值。- 负值 比如 -5 ， -6， -7.
sizeof 计算变量类型的大小
int arr [10] = {0}; printf("%d\n", sizeof(arr)); 0 ` printf(%d\n", sizeof(arr) / sizeof （arr[0]);*间接访问操作符（解析引用操作符）
（类型） 指针变量 *p(变量 结构体) 代表存放变量的地址 *p（变量 在结构体外在函数内 则表示解指针地
//这边重点讲讲永不上的但是必须要知道的
NAND 与非运算 有0则1，全1则0.
NOR 或非运算 有1则零 全0则1;
XNOR 同或运算符 相同则1，不同则0;
#include <stdio.h>
struct Person {
char name[20];
int age;
};
int main() {
struct Person p1 = {"John", 25};
struct Person *ptrP1 = &p1;
printf("Name: %s\n", ptrP1->name);
printf("Age: %d\n", ptrP1->age);
return 0;
}
->箭头符号 "->" 是一个重要的运算符，用于访问结构体指针或联合体指针成员的值。它用于替代点运算符"."，用以对指针所指向的结构体或联合体的成员进行访问。
通过箭头符号，我们可以方便地对结构体指针或联合体指针的成员进行访问。
是由规则 左边一定要是结构体指针 -> 箭头成员变量名
赋值操作符 = += *= /= &= ^= |= >>= <<= ！=用于测试不相等 == 用于比较
#位位位操作符#
& 按位与 对应的2进制只要有0 都为0 一和一才为一
| 按位或 对应的2进制只要有1 都为1 零和零才为零
^ 按位异或 对应的2进制 相同为0 相异为1
#include <stdio.h> int main() { int a = 3; int b = 5; printf("a=%d b=%d\n", a, b); a = a ^ b; b = a ^ b; a = a ^ b; printf("a=%d b=%d\n", a, b); return 0; }
#移位操作符 #
右>> 编译器有俩在移动 逻辑移补0 算术移动补1
-1 ： 源码：数值不变 100000000000000000000001
反码 ：按位取反 111111111111111111111110 ：负号位1不变其余按位取反
补码： （反码 + 1） 111111111111111111111111
左<< 计算机存的是反码 移动的也是 补码
算术操作符 - + / % * **
. 点操作符 s.name s.age 使用场景 在结构体 调出结构体内容 并打印
#运算符#
与运算符 && 需要使用关键字 表示将多个连接成一个 条件表达式必须为 true false
或运算 || 需要使用关键字 表示将多个连接成一个 条件表达式必须为 true false
非运算符 ！ 用于将单个表达式结果取反， 如果原表达式的结果为 false ，在表达式前面加上运算符 ! 结果取反之后就是 true ；如果原计算结果是 true ，在表达式前面加上运算符 ! 结果取反之后就是 false ；
自动运算符 ++ / -- 作用对变量本身做+1 -1 有俩种形式
前缀形式：
++variable或--variable。这种形式表示先递增（递减）变量的值，然后返回递增（递减）后的值。后缀形式：
variable++或variable--。这种形式表示先返回变量的当前值，然后再递增（递减）变量的值。#include <stdio.h> int main() { int a, b, c; a = 5; c = ++a; b = ++c, c++, ++a, a++; b += a++ + c; printf("a = %d, b = %d, c = %d\n", a, b, c); return 0; } //a = 9, b = 23, c = 8 //首先，++c会将c的值加1，并且将结果赋给b。所以，这时候b的值为7，c的值为7。 //然后，c++会将c的值加1，但返回的是加1前的值（后置递增运算符返回的是原始值）。 //所以，这时候c的值变为8，b和c的值都为7。 //然后，++a会将a的值加1，所以此时a的值为7。 //最后，a++会将a的值赋给b，然后再将a的值加1，所以此时b的值为7，a的值为8。 //首先，将a的值（8）加到b(7)上，然后再加上c的值（8）。因此，此时b的值为23。 //最后，我们使用printf函数打印变量的值
在 C 语言中，
++和--运算符可以用于修改变量的值，但需要注意以下几点：避免在同一表达式中多次修改同一个变量，这会导致代码可读性下降和潜在的未定义行为。
在使用
++和--运算符时，要注意前缀形式和后缀形式的区别。因为它们的行为可能在不同语境下产生不同结果。
避免在同一表达式中多次修改同一个变量，这会导致代码可读性下降和潜在的未定义行为。
在使用
++和--运算符时，要注意前缀形式和后缀形式的区别。因为它们的行为可能在不同语境下产生不同结果。
#include <stdio.h>
int main() {
int a = 5, b = 5;
printf("Original value of a: %d\n", a);
printf("Original value of b: %d\n", b);
// Prefix increment
printf("Prefix increment a: %d\n", ++a);
// Postfix increment
printf("Postfix increment b: %d\n", b++);
printf("Final value of a: %d\n", a);
printf("Final value of b: %d\n", b);
return 0;
}
C语言数据类型
基本类型 ： 结构类型： 指针类型： 空类型：
数值类型 数组
结构体：struct 变量的结合 值的类型可以不一样（char int short float) 假描述一个人用这些单独 类型可能无法表述 定义结构体
#include <stdio.h>
struct B
{
char c;
short s;
double d;
};
// 结构体体的成员可以是列一个结构体 也可以是列一个数组
struct Stu {
struct B sb;
char name[20]; //表述一个学生 名字
int age; //年龄
char id[20]; //身份证号
};
//} s1,s2;
// 这里的s1 s2 区别是全局变量 也是结构体变量
//结构体变量声明 告诉编译器 结构体变量里面有哪些成员
void print1(struct Stu t) //传参
{
printf("%c %d %lf %s %d %s", t.sb.c, t.sb.s, t.sb.d, t.sb.name, t.sb.age, t.sb.id); // %lf 是打印double 类型的浮点数
printf("%s\n", t.id);
}
int main()
{
//s1 是静态变量 传过来的是数组 必须要初始化 结构体方的是多个成员 创建变量的同时也要赋值
struct Stu s = {{'w', 20, 3.14}, "张三", 30, "12312321"}; //Stu s1 是调用结构体 的变量对象把一些通用的写在结构体里面 在调用对象时加上可变化不用的数值变量
printf("%c", s.sb.c); // 点符号找结构体里面的成员 在点c 结构体变量
printf("%s\n", s.id);
//假如我要写一个打印函数 这种叫传值调用 需要开辟空间 传给型参的时候接受的时候也要开辟空间 缺点空间造成浪费
print1(s);
//这种叫传址调用 优点是传地址不用考虑结构体里面的成员
print2(&s); // 接受的时候要传地址 print2(struct Stu *p) ps->sb.c ps->sb.s ps->sb.d ps->sb.name ps->sb.age ps->sb.id 用ps -> 指向哪里
struc Stu* ps = &s; //这颗型说明是指向结构体变量的指针
printf("%s\n", (*ps).sb.c); // 如果结构体变量是ps 就可以用j解开*ps 然后找到 sb.c 点是在结构体里找c
printf("%s\n", ps->sb.c); //ps ->id 找到结构体里面的成员id 然后点找到c变量
return 0;
}
struct Point
{
int x;
int y;
}p1; //声明一个结构体变量p1
struct Point p2; //也可以拿这个结构体创建另一个变量
struct Point p3 = {10 , 20}; // 也可以在声明变量时赋值 变量
共用体： union
字符类型 枚举类型
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
//这里定义了一个名为Data的union。这个union有三个成员：一个整数i，一个浮点数f，和一个字符数组str。这些成员都共享相同的内存空间，因此它们的大小应该是相等的或者小于str的大小（因为str是最大的成员）。
int main( )
{
union Data data;
data.i = 10;
data.f = 220.5;
strcpy( data.str, "C Programming");
//这三行代码分别给data的i、f和str成员赋值。但是，由于union的特性，只有最后一个赋值的成员（在这里是str）会保留其值。因此，data.i和data.f的值将被data.str的值覆盖。
printf( "data.i : %d\n", data.i);
printf( "data.f : %f\n", data.f);
printf( "data.str : %s\n", data.str);
//这三行代码分别打印data的i、f和str成员的值。由于上述提到的union的特性，data.i和data.f的值将是不可预测的（通常是垃圾值），而data.str的值将是"C Programming"。
return 0;
}一章：
- int : 占据的内度存大小是2 个byte
- short int : 占据的内度存大小是4 个byte
- long int : 占据的内度存大小是4 个byte
- float : 占据的内度存大小是4 个byte
- double : 占据的内度存大小是8 个byte
- char : 占据的内度存大小是1 个byte
二章：
-
基本数据类型：
- 整数类型（如
int,short,long,char等） - 浮点数类型（如
float,double） - 布尔类型（
_Bool,bool） - 空类型（
void）
- 整数类型（如
-
派生数据类型：
- 数组类型
- 结构体类型
- 联合类型
- 枚举类型
-
指针类型：指向内存地址的指针类型（如
int*,char*,void*等） -
复合类型：
- 函数类型
- 指针类型
- 数组类型
- 结构体类型
- 联合类型
-
自定义数据类型：通过
typedef关键字定义的自定义类型
需要注意的是，C 语言是一种静态类型语言，因此在编译时类型需要确定，并且根据需要进行显式的类型转换。以上列出的类型是 C 语言中常见的类型，您可以根据需要选择合适的类型来定义变量、函数等。
三目运算符
三目运算符 有三个可操作得运算符
| 计算结果 = 表达式 ？ | |
| 表达式2 ：表达式3 | |
| 表达式1 ？表达式2 ： 表达式3 返回值 先求表达式1得值 如果为真 则执行表达式2 并返回表达式2得结果 如果表达式1得值为假则表示3 得结果 |
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
int max = a > b ? a : b;
printf("max=%d\n", max);
return 0;
}#C语言变量名#
变量名 开头不可使数字
\变量名是系统专用
注意：C变量不可使关键字 变量名不可以有空格 C语言是区分大小写的 n N是不同得变量
比介绍一种变量命名方法 匈牙利命名法
属性部分
g_ 全局变量
c_ 常量
m_ C++类成员变量
s_ 静态变量
类型部分
数组 a
指针 p
长指针 Long Pointer
函数 fn
无效 v
句柄 h
长整型 l
布尔 b
浮点型（有时也指文件） f
双字 dw
字符串 sz
短整型 n
双精度浮点 d
计数 c（通常用cnt）
字符 ch（通常用c）
整型 i（通常用n）
字节 by
字 w
实型 r
无符号 u
描述部分
最大 Max
最小 Min
初始化 Init
临时变量 T（或Temp）
源对象 Src
目的对象 Dest
MFC 句柄 控件 及结构得命名规范
Windows类型 样本变量 MFC类 样本变量
HWND hWnd CWnd* pWnd
HDLG hDlg CDialog* pDlg
HDC hDC CDC* pDC
HGDIOBJ hGdiObj CGdiObject* pGdiObj
HPEN hPen CPen* pPen
HBRUSH hBrush CBrush* pBrush
HFONT hFont CFont* pFont
HBITMAP hBitmap CBitmap* pBitmap
HPALETTE hPaltte CPalette* pPalette
HRGN hRgn CRgn* pRgn
HMENU hMenu CMenu* pMenu
HWND hCtl CState* pState
HWND hCtl CButton* pButton
HWND hCtl CEdit* pEdit
HWND hCtl CListBox* pListBox
HWND hCtl CComboBox* pComboBox
HWND hCtl CScrollBar* pScrollBar
HSZ hszStr CString pStr
POINT pt CPoint pt
SIZE size CSize size
RECT rect CRect rect
变量命名规范
ch char 8位字符 chGrade
ch TCHAR 如果_UNICODE定义，则为16位字符 chName
b BOOL 布尔值 bEnable
n int 整型（其大小依赖于操作系统） nLengt
n UINT 无符号值（其大小依赖于操作系统） nHeight
w WORD 16位无符号值 wPos
l LONG 32位有符号整型 lOffset
dw DWORD 32位无符号整型 dwRange
p * 指针 pDoc
lp FAR* 远指针 lpszName
lpsz LPSTR 32位字符串指针 lpszName
lpsz LPCSTR 32位常量字符串指针 lpszName
lpsz LPCTSTR 如果_UNICODE定义，则为32位常量字符串指针 lpszName
h handle Windows对象句柄 hWnd
lpfn callback 指向CALLBACK函数的远指针
前缀 符号类型 实例 范围
IDR_ 不同类型的多个资源共享标识 IDR_MAIINFRAME 1～0x6FFF
IDD_ 对话框资源 IDD_SPELL_CHECK 1～0x6FFF
HIDD_ 对话框资源的Help上下文 HIDD_SPELL_CHECK 0x20001～0x26FF
IDB_ 位图资源 IDB_COMPANY_LOGO 1～0x6FFF
IDC_ 光标资源 IDC_PENCIL 1～0x6FFF
IDI_ 图标资源 IDI_NOTEPAD 1～0x6FFF
ID_ 来自菜单项或工具栏的命令 ID_TOOLS_SPELLING 0x8000～0xDFFF
HID_ 命令Help上下文 HID_TOOLS_SPELLING 0x18000～0x1DFFF
IDP_ 消息框提示 IDP_INVALID_PARTNO 8～0xDEEF
HIDP_ 消息框Help上下文 HIDP_INVALID_PARTNO 0x30008～0x3DEFF
IDS_ 串资源 IDS_COPYRIGHT 1～0x7EEF
IDC_ 对话框内的控件 IDC_RECALC 8～0xDEEF
应用程序符号命名规范
Microsoft MFC宏命名规范:
名称 类型
_AFXDLL 唯一的动态连接库（Dynamic Link Library，DLL）版本
_ALPHA 仅编译DEC Alpha处理器
_DEBUG 包括诊断的调试版本
_MBCS 编译多字节字符集
_UNICODE 在一个应用程序中打开Unicode
AFXAPI MFC提供的函数
CALLBACK 通过指针回调的函数
库标识符命名法
标识符 值和含义
u ANSI（N）或Unicode（U）
d 调试或发行：D = 调试，忽略标识符为发行。
静态库版本命名规范:
库 描述
NAFXCWD.LIB 调试版本：MFC静态连接库
NAFXCW.LIB 发行版本：MFC静态连接库
UAFXCWD.LIB 调试版本：具有Unicode支持的MFC静态连接库
UAFXCW.LIB 发行版本：具有Unicode支持的MFC静态连接库
动态连接库命名规范:
名称 类型
_AFXDLL 唯一的动态连接库（DLL）版本
WINAPI Windows所提供的函数
Windows.h中新的命名规范:
类型 定义描述
WINAPI 使用在API声明中的FAR PASCAL位置，如果正在编写一个具有导出API人口点的DLL，则可以在自己的API中使用该类型
CALLBACK 使用在应用程序回叫例程，如窗口和对话框过程中的FAR PASCAL的位置
LPCSTR 与LPSTR相同，只是LPCSTR用于只读串指针，其定义类似（const char FAR*）
UINT 可移植的无符号整型类型，其大小由主机环境决定（对于Windows NT和Windows 9x为32位）；它是unsigned int的同义词
LRESULT 窗口程序返回值的类型
LPARAM 声明lParam所使用的类型，lParam是窗口程序的第四个参数
WPARAM 声明wParam所使用的类型，wParam是窗口程序的第三个参数
LPVOID 一般指针类型，与（void *）相同，可以用来代替LPSTR
举例
hwnd ： h 是类型描述，表示句柄， wnd 是变量对象描述，表示窗口，所以 hwnd 表示窗口句柄；
pfnEatApple ： pfn 是类型描述，表示指向函数的指针， EatApple 是变量对象描述，所以它表示指向 EatApple 函数的函数指针变量。
g_cch ： g_ 是属性描述，表示全局变量，c 和 ch 分别是计数类型和字符类型，一起表示变量类型，这里忽略了对象描述，所以它表示一个对字符进行计数的全局变量。
MFC、句柄、控件及结构的命名规范：
Windows类型 样本变量；MFC类 样本变量
HWND hWnd；
CWnd* pWnd；
HDLG hDlg；
CDialog* pDlg；
HDC hDC；
CDC* pDC；
HGDIOBJ hGdiObj；
CGdiObject* pGdiObj；
HPEN hPen；
CPen* pPen；
HBRUSH hBrush；
CBrush* pBrush；
HFONT hFont；
CFont* pFont；
HBITMAP hBitmap；
CBitmap* pBitmap；
HPALETTE hPaltte；
CPalette* pPalette；
HRGN hRgn；
CRgn* pRgn；
HMENU hMenu；
CMenu* pMenu；
HWND hCtl；
CState* pState；
HWND hCtl；
CButton* pButton；
HWND hCtl；
CEdit* pEdit；
HWND hCtl；
CListBox* pListBox；
HWND hCtl；
CComboBox* pComboBox；
HWND hCtl；
CScrollBar* pScrollBar；
HSZ hszStr；
CString pStr；
POINT pt；
CPoint pt；
SIZE size；
CSize size；
RECT rect；
CRect rect；
#printf 函数#
printf 是格式化输出函数
printf 函数执行原理
int printf(const char *format, ...)
printf("<格式化字符串>", <参量表>）；
puts是 C 语言中的一个标准库函数，用于将字符串输出到标准输出（通常是终端或控制台）。puts函数会输出指定的字符串，并在输出后自动添加一个换行符（\n）。
- %d 十进制有符号整数(decimalism)
- %u 十进制无符号整数(unsigned)
- %f 浮点数(floating)
- %s 字符串（string）
- %c 单个字符（character）
- %p 指针的值(pointer)
- %e 指数形式的浮点数(exponent)
- %x, %X 无符号以十六进制表示的整数(hexadecimal)
- %o 无符号以八进制表示的整数(octonary)
- %g 把输出的值按照 %e 或者 %f 类型中输出长度较小的方式输出
- %p 输出地址符
- %lu 32位无符号整数
- %llu 64位无符号整数
- 插一条 逗号表达式使用列子
- a=3*5,a*4 //a=15,表达式60值
- a=3*5,a*4,a+5 //a=15 表达式值20
- x=(a=3,6*3) //赋值表达式 值18 x=18
- 其实，逗号表达式无非是把若干个表达式“串联”起来。在许多情况下，使用逗号表达式的目的只是想分别得到各个表达式的值，而并非一定需要得到和使用整个逗号表达式的值，逗号表达式最常用于循环语句(
for语句) -
—if 语句
-
#include "stdafx.h" #include <stdio.h> int main() { //说法一： // 如果没结婚,就是女生; // 如果结婚了,那就是女人; // bool 只有两种结果，要么为true 要么为false bool bMarry = false; if (true == bMarry) { //如果结婚了，才能执行下面这一行代码 printf("结过婚了，是女人！\n"); } printf("main函数结束！\n"); return 0; } 要判断一个数不是在100和50之间，需要满足两个条件： 数不大于50 数不小于100 if (number <= 50 || number >= 100): 输出 "数不在100和50之间" else: 输出 "数在100和50之间" 要判断一个数是在100和50之间，需要满足两个条件 大于 > 50 生成了 51 51 .... ||一个为真 && 俩个真才为真 必须小于 <100 ^异或 对比不同的 相同假 不同真 | 相同为真 不同为假
#for循环#
for(表达式1； 表达式2； 表达式3；）{
语句块
）
我要生成 100( 到 10之前的数字
for (int i = 1; i < 100; i++){
}
我判断这个数在 100() 到 10之前的数字
if ( i >= 100 || i < 10)
- a.先执行 表达式 1 (用于对变量初始化操作，仅仅只会执行一次);
- b.再执行
表达式 2，如果表达式 2为真，则执行循环体，否则结束循环;- c.执行完循环体后再执行
表达式 3做自增++/ 自减--操作;- d.重复执行步骤
c和d，直到表达式 2的值为假，就结束循环;
表达式 1仅在第一次循环时执行（仅仅作为变量初始化使用），以后都不会再执行。表达式 2一般是一个关系表达式，决定了是否还要继续下次循环，称为循环条件。表达式 3很多情况下是一个C 语言自增 ++ / 自减 — 表达式，以使循环条件逐渐变得“不成立”。
static
用法 1. 修饰局部变量
2. 修饰全局变量
2. 修饰函数
#include <stdio.h> void test() { int a = 1; a++; printf("%d", a); } int main() { int i = 0; while (i < 10) { test(); i++; } return 0; } //结果222222222#include <stdio.h> void test() { static int a = 1; a++; printf("%d", a); } int main() { int i = 0; while (i < 10) { test(); i++; } return 0; } //结果 234567891011加入static 变量后就会不销毁 （本质时改变了变量存储类型 局部变量的生命周期）
static 就是把栈区的变量 放到了静态区
+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+#+##+#+#+#+#+#+#+#+#+#+#+#++##+#+#+#+#+#+#+#+#
____________ 指针_________
介绍 指针也可以叫地址 通过地址编号 寻找对应内存单元的数据 加入 我的1个字节分别是 11 22 33 44 数据 放在了01f 栈内 通过指针可以找到这个数据地址
#include <iostream>
#define LOG(x) std::cout << x << std::endl;
void Increment(int* value){
(*value)++;
}
int main(){
int a = 10;
int* ptr = &a;
*ptr = 20;
LOG(a);
/*创建一个 ptr 指针，指向 int 型变量，并将其赋值为 &a，然后将 ptr 指向的 int 型变量的值加 1 */
st什么情况指针
地址的类型装换 p = (char *) 0xa000
void HariMain(void)
{
int i;
char *p;
for (i = 0xa0000; i <= 0xaffff; i++) {
p = i; /*0xa0000到0xaffff在bios存放的是颜色像素显示*/
*p = i & 0x0f; /*将p的值拿出来与 i & 与运算 0x0f 的值进行赋值*/
/*简便写法*/
}
/*简便写法*/
void HariMain(void)
{
int i;
p = (char *) 0xa0000; //将地址转换成char类型
for (i = 0; i <= 0x0ffff; i++){
*(p + i) = i & 0x0f; //p + i指针算术操作(指定为算术操作[末尾补1]) 如果p指向了一个元素
//那么p +i指向了 i + 1个元素
//也可以这么写p[i]
}
数组
函数传递
动态分配内存
字符串操作
动态数据结构
传递大型数据结构
访问硬件底层资源
指针在32位系统是4字节 64位就是 8字节
int main()
{
int a = 0x11223344;
int *pa = &a;
*pa = 0;
}
这是 a的地址假如我们想让他变成别的 *pa = 0; 指向这个地址赋值
*p = 0;后
注意 指针类型发生变化 访问权限也发生变化
int main()
{
int a = 0x11223344;
char* pc = &a;
*pc = 0;
return a;
}￥￥￥￥指针类型%%%%%
如果你想让他一个字节字节的走交给 char * 指针 如果你想维护一个元素交给整形 指针
野指针
造成野指针 指针为初始化 内存动态分配 不完全
#include <stdio.h>
#include <stdlib.h>
#include<string.h>
int main()
{
int* p; //未指向地址 随机地址
*p = 20;// 非法访问内存
//你会发现他的地址都是 每次都不一样
return 0;
}#include <stdio.h>
#include <stdlib.h>
#include<string.h>
int main()
{
int arr[10] = { 0 };
int* p = arr;
int i = 0;
for (i = 0; i <= 10; i++);
{
*p = i;
p++;// 指针会越界访问 此时p++ 超出了数组访问 造成了野指针
}
return 0;
}#include <stdio.h>
#include <stdlib.h>
#include<string.h>
static int* test()
{
int a = 10;
return &a;
}
int main()
{
char *p = test();
*p = 20;
return 0;
}
/* int *p 访问test 返回一个地址 将20 写入地址 p里去
但是 int 是aout 自动销毁 也就是释放了 再去访问 p的地址就是没有了
系统会随机访问一个地址 那就是野指针 */* p指向指针的内容 p 本身就是指针变量
*p 解开指针的内容
#include <stdio.h>
int main(){
int n = 100;
//const 是常量类型修饰符，用来修饰变量，表示该变量是常量，不能被修改
const int a = 10;
//const 修饰指针 指针指向的变量不能被修改
const int* p = &a; //const *放在左边 修饰的是指针指指向的内容不能通过指针改变
int* const p1 = &a; //const *放在右边 修饰的是指针本身，不能通过指针改变指针指向的内容
//p = &n; //p指向的是p变量本身 没有指向内容将变量的值取出来
//*p = 20; // 通过指针修改指向的内容
printf("%d\n", &n);
return 0;
}____内存__________
pa 变量
#include <stdio.h>
int main()//分配内存空间4字节
{
int a = 10;
printf("%p\n", &a);
int* pa = &a;//pa指针变量 说明pa执行的对象是int类型
*pa = 20；/*这里的* 操作就是解引用 *pa就是通过pa 里边的地址 找到a*/
return 0;
}
指针 变量用来存放别人的地址 指针是有类型的 假如有一天我要找到这个地址 可以通过解引用操作符来找到这个地址
#include <stdio.h> int main() { printf("%d\n", sizeof(char*)); printf("%d\n", sizeof(short*)); printf("%d\n", sizeof(int*)); printf("%d\n", sizeof(long*)); printf("%d\n", sizeof(long long*)); printf("%d\n", sizeof(float*)); printf("%d\n", sizeof(double*)); return 0; }||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||下面就是一个复习||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
C语言中的char是一种数据类型，用于表示字符型变量。它是一个字节大小的整数，范围通常为-128到127或0到255，具体取决于系统的实现。
使用char可以存储单个字符或特殊字符（如换行符，回车符等）。它可以用于声明字符数组或字符串，以及在控制台或文件中读取和输出字符。
以下是一些常见的char操作和用法示例：
声明一个char变量： char c;
初始化一个char变量： char c = 'A';
声明和初始化一个字符数组： char str[] = "Hello";
读取和输出字符： scanf("%c", &c); // 从用户输入中读取一个字符 printf("%c", c); // 输出一个字符
字符串处理： char str1[] = "Hello"; char str2[] = "World"; strcat(str1, str2); // 连接两个字符串 strcmp(str1, str2); // 比较两个字符串
遍历字符串： for (int i = 0; str[i] != '\0'; i++) { printf("%c", str[i]); }
需要注意的是，char类型既可以表示字符，也可以表示数字。当用数字初始化char变量时，该数字会被解释为对应的ASCII码字符。同样，当将字符赋值给char变量时，字符的ASCII码值会被存储。可以使用ASCII码表将字符和对应的ASCII码互相转换。
C语言中的short是一种数据类型，表示短整型变量。它通常占用2个字节（16位）的存储空间，范围为-32768到32767或0到65535，具体取决于系统的实现。
short类型可用于声明短整型变量，它适用于表示较小的整数值，节省内存空间。通常在整数运算、数组索引等场景中使用short类型。
以下是一些short类型的操作和用法示例：
1. 声明一个short变量：
short num;2. 初始化一个short变量：
short num = 10;3. 进行short类型之间的运算：
short a = 5;
short b = 3;
short sum = a + b;4. 使用short类型进行数组索引：
short arr[] = {1, 2, 3, 4, 5};
short value = arr[2]; // 获取数组中索引为2的元素值5. 使用short类型进行循环计数：
for (short i = 0; i < 10; i++) {
// 执行循环体操作
}需要注意的是，short类型的取值范围相对较小，如果需要表示更大或更精确的整数，可以考虑使用int类型。另外，short类型也可以通过强制类型转换转换为其他类型，如将short转换为int或float类型进行计算。
在C语言中，double是一种数据类型，用于表示双精度浮点数。它通常占用8个字节（64位）的存储空间，范围和精度较float类型更大。
以下是double类型的一些操作和用法示例：
1. 声明一个double变量：
double num;2. 初始化一个double变量：
double num = 3.14;3. 进行double类型之间的运算：
double a = 2.5;
double b = 1.2;
double sum = a + b;4. 使用double类型进行科学计算：
#include <math.h>
double result = pow(2.0, 10.0); // 计算2的10次方5. 使用double类型进行金融计算：
double balance = 1000.0;
double interestRate = 0.05;
double interest = balance * interestRate;需要注意的是，double类型在计算机内部实现时，可能会存在一定的精度误差。因此，在比较double类型的变量时，通常需要考虑使用误差范围或其他技巧来进行判断。另外，如果不需要高精度的浮点数计算，可以考虑使用float类型以节省内存空间。
_________数据在内存存储
#分支语句和FOR 循环#
分支语句
- if
-
int main() { int age = 10; if ( age >= 18) printf("成年\n"); else { printf("未成年\n“); printf("不能谈恋爱\n"); } //如果你想让他打印俩条语句 一定要给带上{} 组成一个代码块 return 0; } 还有一种不常用 int main() { int age = 10; if (age >=10) printf("成年\n"); return 0; }
-
int main() { int age = 130; if (age <= 18) pritf("少年\n”); else (age> = 18 && age <= 16) printf("未成年\n"); else if(age >= 26 && age <= 50) printf("青少年\n"); else (age >=60 && age <= 100) printf("老年\n"); //这就是多分支可以一直写下去 // {} 代码块包含起来 return 0; } -
#include <stdio.h> //int main() //{ // int i = 0; // for (i = 1; i <= 100; i++) // { // printf("%d ", i); // } // return 0; //} //c++写法 int main() { for (int i = 1; i <= 100; i +=2 ) { printf("%d ", i); } return 0; } // c语言写法打印出1-100 数字方法
-
swich
循环语句
- while 分支循环
- asce 整形判断
- for 单循环
- do while （do 是先判断在执行）
- do
do 循环语句 while (表达式)do 循环体必须要执行一次
跳
- goto 跳转
- continue 满足条件跳转
- getchar 取一个字符
- putchar 从键盘打印出一个字符
- break 永久跳出循环
语句介绍
语句 在c语言中有分号（；）隔开的就是语句
；也代表语句代表空语句
————————数组————
#include <stdio.h>
int main() {
int arr[12] = {31, 28,31,30,31,30,31,31,30,31,30,31};
//定义一个数组，存储12个月的天数
for (int i = 0; i < 12; ++i){
//遍历数组，输出月份的天数
int days = arr[i];
//取出数组从0开始数组是从0开始的 赋值给days
printf("2022年 %d 月的天数：%d天\n", (i + 1), days);
}
}数组是从0开始
int 占用 4字节 char 占用1个字节
数组可以作为函数
数组在传参时是指针
数组一定要明确类型和大小， 因为数组是一块连续的内存空间。生成之后就固定了。
变成数组
c99 支持别的不支持
int arr[10] ={0};
int n =0;
scanf("%d, &n");
int arr[n];数组可以在一个变量里定义多个值
*p //数组第一个元素 p //数组第一个元素的地址 p == str //因为str就是首元素地址 所以这里对地址*代表第一个元素之使用的是指针表示法 *str //因为str就是首元素地址 这里*代表地址加*就代表第一个元素 使用的是指针表示法 &str //这里得到的实际上还是首元素地址 *(p + 1) //代表第二个元素 p + 1 //代表元素的内存地址 *p + 1 //注意*的优先比+要高 这里代表的是首元素的值+ 1 得到字符K
不安全初始化
#include <stdio.h>
int main() {
int arr[12] = {1,2,3,4};
}
//不完全初始化会导致其余初始化位置变成0如果我想第改变三个值的
int arr[12] = {[3] = 30, [10] = 31};#include <stdio.h>
int main(){
int arr[12] = {31,28,31,30,31,30,31,31,30,31,30,31,};
for (int i = 0;i < sizeof(arr)/sizeof(arr[0]);i++){
if(arr[i] > 30){
printf("%d 月大于30天： \n", i + 1);
}
}
}改变数组的值
#include <stdio.h>
int main(){
int arr[12] = {31,28,31,30,31,30,31,31,30,31,30,31,};
for (int i = 0; i < 12; i++){
if(arr[i] < 31) arr[i] = 0;
//将每一个行的数组打印出来符合小于31的数赋值为零
}
for (int i = 0;i < sizeof(arr)/sizeof(arr[0]);i++){
//sizeof计算数组大小 12除 （sizeof[0]数组的第一个元素也也就是1)直接处于0是0
//打印出每个数组
printf("%d ",arr[i]);
}
}———二维数组——————
如何访问二维数组的单独的数
#include <stdio.h>
int main() {
int arr[][12] = {{1, 2, 3, 4, 5, 6, 7, 8, 9},
{1, 2, 3, 4, 5, 6, 7, 8, 9},
{1, 2, 3, 4, 5, 6, 7, 8, 9}};
return ("%d", arr[1][2]);
}_____死循环
#include <stdio.h>
//错误代码越界访问
int main(){
int i = 0;
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for(i = 0; i < 12; i++){
arr[i] = 0; //
printf("hello\n");
}
printf("i的地址是%p\n", &i);
printf("arr的地址是%p\n", &arr[9]);
}
/*i 和arr 是局部变量
数组在栈区中随着下标的增长 地址是由低到高的变化
debug 版本
release 版本
*/————冒泡排序算法
#include <stdio.h>
int main() {
int arr[10] = {1, 2, 3, 4, 4, 7, 8, 6, 1, 2};
//数组的重写排列
for (int i = 0; i < 10; ++i) {
for (int j = 1; j < 10; ++j) {
if (arr[j] < arr[j - 1]) {
int temp = arr[j -1];
arr[j -1] = arr[j];
arr[j] = temp;
}
}
}
for (int i = 0; i < 10; ++i) {
printf("%d ", arr[i]);
}
}
/** 外部循环`i`从0到9（共10次），控制排序的轮数。
* 内部循环`j`从1到9（共9次），在每轮中负责比较和交换相邻的元素。
* `if (arr[j] < arr[j - 1])`：如果当前元素`arr[j]`小于前一个元素`arr[j - 1]`，则交换它们。
* `int temp = arr[j -1];`：使用一个临时变量`temp`来存储`arr[j - 1]`的值。
* `arr[j -1] = arr[j];`：将`arr[j]`的值赋给`arr[j - 1]`。
* `arr[j] = temp;`：将`temp`（即原来的`arr[j - 1]`）的值赋给`arr[j]`。
*/---—————链表
像自行车的链条一样 他和数组不一样的是 数组是固定的空间 假如我申请10个数字的空间 1234....10就是10个接受也是固定的
如果我申请的空间大小不一 是动态的随机在变化 这时候就要用到链表（linked list)以数据的方式存储他们 链表是由一连串元素（称为节点）构成 每个节点包括存储的数据以及一个指针-> 他指向下一个节点 当程序读取数据时 创建一个节点（使用maUocO函数）并将其添加在链表尾部 输入结束的时候 将预留一个节点列表 改列表包含 数据项 以及下一个申请空间的指针节点 注意最后一个指针的值为NULL 在ANSIC中将该指定为空指针 当程序遇到NULL则表示走到尽头该停下来了 每个链表以一个简单的指针开始 他指向第一个数据项
链表地址链表超详细
#include <stdio.h>
#include <assert.h>
char *my_strcpy(char* dest, const char* src){
// 起始地址 目标地址 返回起始地址
assert(dest != NULL && src != NULL); //断言
char* ret = dest;
while (*dest++ = *src++) {
; //跳出循环后，dest和src都指向了字符串的末尾
}
return ret; //返回目标字符串的首地址
}
int main(){
char arr[20] = "xxxxxxxxxxxxx";
char arr2[] = "hello";
//1.目标空间地址 2.源空间起始地址 3.返回值
printf("%s\n", my_strcpy(arr, arr2));
//在my_strcpy 函数 返回在printf 函数 函数在另一个函数里就是链式访问
assert(strcmp(arr, "hello") == 0);
return 0;
}
/*一个函数最为另一个函数的参数 返回值 就是链式访问*/------------作用域----
#include <stdio.h>
void myFunction() {
int x = 5; // x具有函数作用域，只能在myFunction函数内部访问
printf("x = %d\n", x);
}
int main() {
myFunction();
// printf("%d\n", x); // 试图在main函数中访问x将会导致编译错误
return 0;
}
#include <stdio.h>
int globalVar = 10; // globalVar具有文件作用域，在整个文件内可见
void myFunction() {
printf("globalVar = %d\n", globalVar); // 可以在函数内部访问globalVar
}
int main() {
printf("globalVar = %d\n", globalVar); // 也可以在main函数中访问globalVar
return 0;
}
#include <stdio.h>
int main() {
int x = 5; // x具有块作用域，只能在if语句内部访问
if (x > 3) {
int y = 10; // y具有块作用域，只能在if语句内部访问
printf("x = %d, y = %d\n", x, y);
}
// printf("%d\n", y); // 试图在if语句外部访问y将会导致编译错误
return 0;
}
______一些没有用的
int main() 原型
#include <stdio.h>
int main(int argc, char **argv, char **environ)
{
printf("Hello, world!\n");
return 0;
}
int main(int argc, char **argv, char **environ)： 这是程序的主函数，程序从这里开始执行。main 函数接受三个参数：
int argc：表示命令行参数的数量。它至少为 1，因为程序名总是作为第一个参数。
char **argv：是一个指向字符指针数组的指针，这个数组包含了所有的命令行参数。argv[0] 是程序的名字，argv[1] 是第一个命令行参数，依此类推。
char **environ：是一个指向环境变量数组的指针。这个数组包含了所有的环境变量。在这个例子中，environ 参数并没有被使用。
{： 这个符号标志着 main 函数的开始。
for (int i = 0; i < argc; ++i)
{
puts(argv[i]);
}
//把这参数打印出来#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
int my_strlen(const char* arr) {
//int 代表返回的类型 如何返回数字就int 返回字符串就char*
assert(arr != NULL);
int count = 0;
while (*arr != '\0') {
count++;
arr++;
}
return count;
}
int main(void) {
char arr[10] = "hello word";
//这里的[10明显错误]
printf("%d", my_strlen(arr));
return 0;
}C++部分他俩是分开的C++比c要自由也不算太自由能理清这些东西就好 c++咋写都乱
c++ 关键字
new
// 单个对象的动态分配 MyClass *obj = new MyClass; // 数组的动态分配 int *arr = new int[10]; //即在堆上创建对象实例。 MyClass *obj = new MyClass; //返回指向分配内存的指针，可以用于后续对该内存的操作。 MyClass *obj = new MyClass; //new会抛出std::bad_alloc异常，可以在代码中捕获并处理 MyClass *obj = new MyClass; //如果内存分配失败，new会抛出std::bad_alloc异常，可以在代码中捕获并处理 try { MyClass *obj = new MyClass; } catch (std::bad_alloc &ex) { // 处理内存分配失败的情况 } //可以使用new来调用对象的构造函数进行初始化。 MyClass *obj = new MyClass(arg1, arg2); //使用delete释放new分配的内存，防止内存泄漏。 delete obj; delete[] arr; // 删除动态分配的数组 //new和delete可以被重载，以实现自定义的内存分配和释放行为 void *operator new(size_t size) { // 自定义的内存分配逻辑 } void operator delete(void *ptr) { // 自定义的内存释放逻辑 } //new可以用于动态分配数组。 int *arr = new int[10];
类型
using namespace std; //命令空间
#include <iostream>
using namespace std;
int main() {
cout << "Hello, world!" << endl;
return 0;
}
using NewTypeName = ExistingType; //命名类型
using Distance = int;
using String = std::string;
Distance distance = 10;
String name = "John";
using std::cout;
using std::endl;使用特定命名空间
#include <iostream> using std::cout; using std::endl; int main() { cout << "Using specific namespace members" << endl; return 0; }
c++ 变量
static int s_Variable = 5; //静态变量
extern int s_Variable; //extern 在外部寻找这个变量的值 外部链接变量
main.c 文件
/*
#include <iostream>
extern int s_Variable;
int main() {
std::cout << s_Variable << std::endl;
std::cin.get();
}
*/
test.c 文件
/*
int s_Variable = 10;
*/
// 这个s_Variable 输出的结果是10科学技术法
float f = 3.0e6; // 表示 3,000,000 正是往后
float g = 2.5e-7; // 表示 0.00000025 负是往前//定一个控制台变量
#define LOG(x) std::cout << x << std::endl;
//指定缺省的命名空间
using namespace std; -
头文件c++
-
#函数声明 (c和c++不一样) c是.h代表头文件 c++是任意 #比如创建一个 log.cpp文件函数 void log(const char* message); //函数声明c++头文件定义加入预处理指令 #program once
检查 文件内的函数是否被重定 包含文件函数不受干扰
创建一个log.h 的函数头文件
#在函数声明文件里也要有头文件的引用 不然头文件知道有个函数 函数不知道有头文件编译就报错
#pragme once //防止重定以预处理 作用::组织单个文件被多次包含 并转换成翻译单元
#include "log.h" //""::引号(绝对路径) <>::代表搜索包含此路径的文件夹
""假如 test文件下有个log.h test.h 当前在test.h下
"../log.h" 代表返回上级目录并搜索 log.h当然这是在绝对路径下
___________________________________________________________________________________
还有一种就是在函数都坐上标记如果你看到相同标记的函数就证明被定义了
#ifndef _LOG_H
#define _LOG_H
函数声明
#endif
/*他会检查_LOG_H 有没有被定义他将执行
如果被定义他将不会执行 他将全部被禁用 */
#ifndef _LOG_H_
#define _LOG_H_
void log(const char* message);
void InitLog();
#endif
::这里需要注意的是 在c++中的预处理命令都是无文件类型这一点是为了和c语言的.h头文件分隔开 c++老头就是这么设计
__C++引用
#include <iostream>
#define LOG(x) std::cout << x << std::endl;
int main(){ // 主函数
int a = 5; // 定义整数变量a并赋值为5
int& ref = a; // 定义整型引用ref 变量a 有了别名
ref = 2; // 修改引用ref所指向的变量a的值为2
LOG(a); // 输出变量a的值
std::cin.get(); // 等待用户输入
}
_______________________________
//也可以创建一个 函数 就像这样
void Increment(int& value)
{
value++;
}
//来调用他
Increment(a)
/* 结果是6*/
___________________________________
另一种内存地址 的引用函数
void Increment(int* value)
{
(*value)++; //他会先解引用在++ (如果不加++他会先递增内存地址其值不变)
*value++; //先增量运算符然后解引用
}
#你想对引用的变量赋值 列子
int main(){
int a = 10; // 初始化变量a为10
int b = 20; // 初始化变量b为20
int* ref = &a; // 定义指针ref指向变量a的地址
*ref = 2; // 通过指针ref将变量a的值修改为2
ref = &b; // 重新将指针ref指向变量b的地址
*ref = 3; // 通过指针ref将变量b的值修改为3
LOG(a); // 输出变量a的值
LOG(b); // 输出变量b的值
}
c++继承
#include <iostream>
#define LOG(x) std::cout << x << std::endl //定义一个LOG宏，用于输出日志信息
#define cin std::cin.get()
using namespace std; //定义命名空间
//一个实体类显示玩家移动的坐标
class Entity {
public:
float X, Y;
void Move(float xa, float ya) {
X += xa;
Y += ya;
LOG("Player moved to (" << X << ", " << Y << ")");
}
};
//一个玩家类继承自实体类，并添加了Name属性
class Player : public Entity { //这里的public继承表示Player类可以访问Entity类的public成员
public:
const char* Name;
void PrintName() {
LOG("Player Name: " << Name);
}
}player;
//显示玩家移动的坐标
void ShowMove() {
player.Name = "John";
player.PrintName();
player.Move(10, 20);
player.PrintName();
}
//主函数
int main() {
ShowMove();
cin;
}c++类
_C++类的 类和结构体不一样的地方在于 花括号末尾的分号
类是包含角色的属性 可以通过点(.)来 取出值 也可以通过函数修改(一定要加 public:)
#include <iostream>
// 定义了一个名为Player的类
class Player {
public:
int x, y; // 玩家的x坐标和y坐标
int speed; // 玩家的移动速度
// 定义了一个移动玩家位置的方法，根据传入的x和y增量来更新玩家的位置
void move(int xa, int ya ) {
x += xa * speed;
y += ya * speed;
}
} player1; // 定义了一个名为player1的Player对象
int main() {
player1.speed=5; // 设置player1的速度为5
player1.move(1, 2); // 调用player1的移动方法，传入x和y增量为1和2
std::cin.get(); // 等待用户输入任意字符后结束程序
}
函数结构
#include <iostream> #include <string> using namespace std; #define LOG(x) cout << x << endl // 类中表示默认得值 struct st_girl { string name; // 女孩姓名 int age; // 女孩年龄 int height; // 女孩身高 double weight; // 女孩体重 char sex = 'X'; // 女孩性别，默认为X string special; // 女孩特点 string memo; // 女孩备注 }girl; // 表示正在变化的值 void setvalue(st_girl &girl, string name, int age, int height, double weight, char sex, string special, string memo) { // 设置女孩信息 girl.name = "西施"; girl.age = 18; girl.height = 170; girl.weight = 98.5; girl.sex = 'X'; girl.special = "无"; girl.memo = "无"; } // 展示女孩信息的函数 void show(st_girl &girl) { // 输出女孩信息 LOG("女孩信息："); LOG("姓名：" << girl.name); LOG("年龄：" << girl.age); LOG("身高：" << girl.height); LOG("体重：" << girl.weight); LOG("性别：" << girl.sex); LOG("特点：" << girl.special); LOG("备注：" << girl.memo); } int main() { // 设置并展示女孩信息 setvalue(girl, "西施", 18, 170, 98.5, 'X', "无", "无"); show(girl); }
结构体成员函数
#include <iostream>
using namespace std;
struct st_girl
{
public:
string name;
int age;
void show(st_girl &girl) //这里不需要传参
{
cout << "姓名：" << girl.name << endl;
cout << "年龄：" << girl.age << endl;
}
};
void setvalue(st_girl &girl,string name,
int age)
{
girl.name = "西施";
girl.age = 18;
}
int main()
{
st_girl girl;
setvalue(girl,"西施",18);
girl.show(girl);
}结构体成员函数的特点 :
可以直接在成员函数中访问成员变量,
struct st_girl
{
string name;
int age;
void show() //在结构体成员中函数不需要传参
{
cout << "姓名：" << girl.name << endl;
cout << "年龄：" << girl.age << endl;
}
};简化写法
#include <iostream>
using namespace std;
struct st_girl
{
string name;
int age;
void show() //显示结构体成员数据的函数
{
cout << "姓名：" << name << endl;
cout << "年龄：" << age << endl;
}
void setvalue(string name1,
int age1) //设置结构体成员数据的函数
{
name = name1;
age = age1;
}
};
int main()
{
st_girl girl;
girl.setvalue("西施", 26); //通过类成员函数设置值
girl.show(); //要在结构体成员函数中使用结构体变量，必须使用引用传递
}
类的访问权限
- public :公有
- private :私有
- protected :保护
- 在类的内部都可以访问不分等级 在外部只能访问工有的 可以添加俩个
- public 在他下边都是共有的
- privata 在他下边都是私有的
也可以递归
struct CGirl //定义结构体
{
int times = 0;
string name;
int age;
void show() //显示结构体成员数据的函数
{
if (times++ > 10) return; //判断是否第一次调用show函数
cout << "姓名：" << name << endl;
cout << "年龄：" << age << endl;
show(); //递归调用show函数
}C++ 可见性
____java
(java)byte -128 - 127之间
(java) boolean 布尔类型
boolean isTrue = true;
if (isTrue) {
System.out.println("条件为真");
} else {
System.out.println("条件为假");
}
运算符 + 字符串连接
'4'+5 = 45
类型转换
可以将整型常量直接赋值给byte、 short、 char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。
科学技术法
java 中默认是double 类型 f 代表转换float类型
float f = 3.0e6f; // 表示 3,000,000
float g = 2.5e-7f; // 表示 0.00000025
____类
什么时候使用类 什么时候使用函数呢
类可以成权限 共有 私有 收保护的 （类用于实现函数之间的调用）
函数则不能 （函数只能功能不能作为权限分配）
单列类(在栈上运行)
#include <iostream>
// 单例模式类
class Singleton {
private:
static Singleton* s_Instance;
public:
// 获取单例实例的静态方法
static Singleton& Get() {return *s_Instance;}
// 例方法
void Hello() {std::cout << "Hello, world!" << std::endl;}
};
// 静态实例的初始化
Singleton* Singleton::s_Instance = new Singleton();
// 一个简单的函数，输出变量i的值
void Function() {
auto int i = 10;
i++;
std::cout << "i = " << i << std::endl;
}
// 主函数
int main() {
// 调用单例实例的Hello方法
Singleton::Get().Hello();
std::cin.get();
}
在堆上运行
#include <iostream>
// 单例模式类
class Singleton {
public:
static Singleton& Get() { //这这里边&代表解开引用 函数已经记住了这个地址下回还会来取
static 静态函数存放值
static Singleton s_Instance;
return s_Instance;
}
void Hello() {
std::cout << "Hello, world!" << std::endl;
}
};
// 主函数
int main() {
// 调用单例实例的Hello方法
Singleton::Get().Hello();
std::cin.get();
}
类中的静态值
#include <iostream>
struct Entity {
static int x, y; // 在这static 是为了使得x和y在整个类中都有效，entity类中的x和y都可以被访问到
private:
static void print() {
std::cout << "x: " << x << " y: " << y << std::endl;
}
};
//如果类中定义静态变量 在外部访问不到，需要在类外定义变量，并初始化
int Entity::x = 0;
int Entity::y = 0;
//在类中引用类中的值并调用类中函数
//如果类中定义静态函数,因为是在类中定一个函数我们访问的是类中的值 在函数中函数的值受作用域限制
//函数的值不可能访问但是函数的功能则可以
// /如果不想让函数的功能被引用出来使用，可以将函数声明为私有，这样外部就无法调用了
int main() {
Entity e;
Entity::x = 11;
Entity::y = 20;
e.print();
Entity e2;
Entity::x = 30;
Entity::y = 40;
e2.print();
std::cin.get();
}______虚函数
虚函数允许我们在子类重写方法功能
______函数
Math 生成随机数
java 生成随机数
import java.util.Random;
public class Main {
public static void main(String[] args) {
// 创建一个Random对象
Random random = new Random();
// 生成一个六位随机数
int randomNum = random.next类型就行(Int Double 首字母要大写)(900000) + 100000;
int RandomNum = (int)Math.random()*4) + 1; //java 中用的是*号 + 1 代表 1 到 4之间数字 默认是double 类型
// 打印生成的随机数
System.out.println("随机数：" + randomNum);
}
}
(c生成随机数)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
int i;
// 设置随机数种子
srand(time(NULL));
// 生成10个随机数并输出
for(i = 0; i < 10; i++) {
printf("%d\n", rand());
}
return 0;
}
#include <iostream>
#include <cstdlib> // 包含rand()函数的头文件
int main() {
int randomNumber = rand() % 7; // 生成一个0到6之间的随机数
int random_num = rand() % 6 + 1; //生成 1到6随机数字
std::cout << "随机数: " << randomNumber << std::endl;
return 0;
}
Scanner 获取键盘输入
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); //获取输出
System.out.println("请输入你的月薪: ");
int age = scanner.nextInt();
System.out.println("请输入你的体重带小数点");
double salary = scanner.nextDouble();
System.out.println("请输入用户名");
String uname = scanner.next();
System.out.println("你的年龄是" + uname);
System.out.println("你的体重是" + salary);
System.out.println("你的月薪是" + (age * 12));
}
}seelp 暂停函数
try {
Thread.sleep(40); //暂停的时间
}
catch (InterruptedException e)
{
throw new RuntimeException(e); //捕获异常
}java 异常函数中
try :执行可能产生异常的代码
catch :捕获异常
try( 语句 } catch (捕获的错误 e){ //这个e 是捕获的值的变量如果向打印取出值 e. 参数(e)一下就好 throw new RuntimeException(e); }
finally : 无论是否异常总能执行
throws : 声明异常
throw : 抛出异常
#控制语句
if语句
package com.game;
public class Test01 {
public static void main(String[] args) {
int i = (int) (Math.random() * 6) + 1;
int j = (int) (Math.random() * 6) + 1;
int k = (int) (Math.random() * 6) + 1;
int count = i + j + k;
System.out.println(count);
if(count>15) {
System.out.println("手气不错,再来一把");
}
if(count>=10&&count<15) {
System.out.println("手气一般");
}
if(count<10) {
System.out.println("不行啊");
}
}
}
switch 分支语句 (whlie 判断)
switch中表达式的值，是int(byte、short、char也可，long不行)、枚举，字符串。
public class Test01 {
public static void main(String[] args) {
int grade = (int)(Math.random()*100) + 1;
switch (grade){
case 1:
System.out.println("大一!不要迷茫 ");
break;
case 2:
System.out.println("不要完啦");
case 3:
System.out.println("时间过的块");
default: //上文没有语句块都没有执行
System.out.println("我们放假的雷");
}
}
}
/*int grade = 1;
if(grade==1) {
System.out.println("大学一年级，可以放松一下，学着谈谈恋爱");
}else if(grade==2){
System.out.println("大学二年级，少玩点游戏，不空虚，不慌嘛？");
}else if(grade==3) {
System.out.println("大学三年级，专业课开始了，好好学，找份好工作");
}else{
System.out.println("大四了，要毕业了。因为跟着尚学堂学习，好工作搞定！");
}*/
判断语句
continue语句
package com.nestingLoop;
//不能被三整处的数输出
public class testLoop {
public static void main(String[] args) {
//100个数字
for (int i = 100; i < 150; i++) {
if(i%3==0){
continue; //能被三整处 不执行下边的语句
}
System.out.print(i+" ");
}
}
}
参考 C语言 error C4996: This function or variable may be unsafe-猿说编程
今天就写到这吧
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
