一、数据类型、输入输出、if条件判断
输入字符scanf("%d", &a) 中，&a 表示变量 a 的地址，&是取地址符
printf 输出时用%d 输出，则输入时也用 %d 输入
//导入库 standard input output 标准输入输出库 .h 头文件
#include <stdio.h>
int main(){
//数据类型
int num; //4个字节，32位
float bb; //4个字节，32位
double cc; //8个字节，64位
char c; //字符型，一个字节，8位
char* str = "abcd"; //字符串
//C语言中，0为false，1为true
//输出包括 %s 字符串 %c 字符 %d 数字 %f 浮点型 %lf 双精度浮点型
printf("输出字符串：%s\n", str);
int a;
printf("请输入：\n");
//scanf 输入值， 从标准输入流stdin读取输入 &a 键盘输入的值并赋值给a
scanf("%d", &a);
printf("输入的值为：%d\n", a);
num = 10;
if(num % 2 == 0 && num > 10){
printf("num为偶数且大于10\n");
}else if(num % 2 != 0 || num < 10){
printf("num可能为奇数或小于10\n");
}else{
printf("均不符合条件\n");
}
return 0;
}
二、循环
C语言各个版本：
其中，对于for循环，只有C99和C11可以使用for(int i = 0; ......)，即在for中初始化 i 的值，其它的版本不能够使用。
Dev-C++5.11如何使用C99,：
1、工具——编译选项
2、在编译器中，勾选 编译时加入以下命令：
并添加 -std=c99，确定后再次运行即运行成功。
运行方法：运行——编译运行（或F11快捷键），运行成功即弹出 command控制台
一维数组：
//c++ 导入库 Input Output流库
#include <iostream>
//使用命名空间 std （standard）标准库
using namespace std;
int main(){
int a[3];
cout<<"请输入："<<endl;
//sizeof 当前变量所占字节数 int占4位 数组则是单个元素*数组长度
//for 循环，在c99和c11可以使用for(int i = 0)，即在for中初始化i的值，之前的不能初始化
for(int i = 0; i < sizeof(a) / sizeof(int); i++){
//输入值，存储在数组中
// scanf("%d", &a[i]); 等同于下方代码
cin>>a[i];
}
cout<<"当前数组内容为 "<<endl;
for(int i = 0; i < sizeof(a) / sizeof(int); i++){
printf("%d 值为：%d\n", i+1, a[i]);
}
//cin<< 获取键盘输入的数，等同于scanf("%d", b)
cout<<"请输入一个数："<<endl;
int b;
cin>>b;
printf("输出b为：%d", b);
return 0;
}二维数组：
#include <iostream>
using namespace std;
int main(){
//定义二维数组
int arrays[2][5];
printf("数组中放入元素\n");
//sizeof(arrays) 二维数组总的字节大小 sizeof(arrays[1])每一行所占字节大小 获取的是有几行
for(int i = 0; i < sizeof(arrays)/sizeof(arrays[1]); i++){
//某一行所占字节数 / int所占字节数 某一行有多少个元素
for(int j = 0; j < sizeof(arrays[i])/sizeof(int); j++){
scanf("%d", &arrays[i][j]);
}
}
printf("获取二维数组中的元素\n");
for(int i = 0; i < sizeof(arrays)/sizeof(arrays[1]); i++){
for(int j = 0; j < sizeof(arrays[i])/sizeof(int); j++){
printf("%d \t", arrays[i][j]);
}
printf("\n");
}
return 0;
}
三、指针
#include <iostream>
using namespace std;
//指针 int/char/double/bool *varName varName变量名
//&varName 取varName的地址
//定义指针 int *varName 解引用，即内存中的值 *varName 操作这个元素的值
//指针变量不确定，则定义 int *a = NULL 没有指向具体的地址，释放申请的空间 NULL其实是0，判断时值为false
//普通变量a = 10可以直接赋值
//指针变量int *p ，p是地址，*p 解引用才能赋值 *p = 1
int main(){
//普通变量， 更改变量的值，变量的地址不发生改变
int a = 10;
cout<<&a<<endl;
a = 900112;
cout<<&a<<endl;
//指针变量，可以记录任意内存空间的地址
int b = 10;
int c = 10;
int d = 10;
//将b的地址，赋值给指针变量p
int *p = &b;
//解引用p，更改指针变量p的值为1，此时由于b与p同时指向同一地址，值均更改
*p = 1;
//将c变量的地址赋值给指针变量p
p = &c;
*p = 1;
p = &d;
*p = 1;
cout<<b<<" , "<<c<<" , "<<d<<endl;
double age = 10.0;
//将age的地址赋值给cityage
double &cityage = age;
cout<<age<<" , "<<cityage<<endl;
//由于cityage和age的地址相同，更改其中一个值时两个变量的值均更改
cityage = 20.0;
cout<<age<<" , "<<cityage<<endl;
return 0;
}
四、#define
#define MaxSize 100，则再次使用MaxSize时，MaxSize 为 100
#include <iostream>
using namespace std;
#define MaxSize 100
//定义： #define 字符串1 字符串2
//define的意义：每当遇见字符串1，就会被替换成字符串2
//不可二次赋值
int main(){
//不可二次赋值
//MaxSize = 50;
int b = 100;
int *p = &b;
*p = 50;
printf("%d\n", b);
int &test = b;
test = 60;
cout<<b<<" , "<<test<<" , "<<*p<<endl;
cout<<MaxSize<<endl;
return 0;
}
五、typedef
typedef int ElemType，此时ElemType a = 10 等价于 int a = 10
#include <iostream>
using namespace std;
//定义：typedef 类型 字符串
//意义：将原本存在的"某类型" ，标识为"字符串"
// 两者在定义变量时等价
typedef int ElemType;
int main(){
ElemType a = 10;
cout << a << endl;
return 0;
}
六、结构体
结构体是另一种用户自定义的可用数据类型，它允许存储不同类型的数据项
由其它类型组成（叫做属性）
结构体属性的访问：普通结构体：用 . 访问
指针结构体：用 -> 访问
方式一：一次性定义出变量
#include <iostream>
using namespace std;
/*
方式一：一次性定义出变量
struct{
属性列表
} 变量1,变量2, ...
*/
struct {
int age;
double height;
}p1, p2;
int main(){
//方式一
//为结构体属性赋值
p1.age = 22;
p1.height = 1.75;
p2.age = 46;
p2.height = 1.78;
//访问结构体属性
cout<<p1.age<<" , "<<p1.height<<" , "<<p2.age<<" , "<<p2.height<<endl;
return 0;
}
方式二：给出结构体名称，稍后再定义变量
#include <iostream>
using namespace std;
/*
方式二：给出结构体名，稍后再定义变量
struct StructName{
属性列表
}
*/
struct Person{
int age;
double height;
};
int main(){
//定义变量 struct StructName 变量名1
struct Person p1;
p1.age = 22;
p1.height = 1.75;
struct Person p2;
p2.age = 46;
p2.height = 1.78;
//访问结构体属性
cout<<p1.age<<" , "<<p1.height<<" , "<<p2.age<<" , "<<p2.height<<endl;
return 0;
}
方式三：用typedef 给出别名，稍后再定义变量
（1）属性列表中没有用结构体本身
#include <iostream>
using namespace std;
/*
方式三：用typedef给出别名，稍后再定义变量
(1) 属性列表没有用结构体本身
typedef struct{
属性列表
}别名;
*/
#define MaxSize 10
typedef struct{
int age;
double height;
}Person, *PPerson, Persons[MaxSize];
void printPerson(Person p){
cout << p.age << " , " << p.height << endl;
}
int main(){
//定义普通变量
Person p;
p.age = 10;
p.height = 1.75;
printPerson(p);
//指针变量
PPerson pp = &p;
pp->age = 17;
pp->height = 1.85;
printPerson(p);
printPerson(*pp) ;
//数组
Persons s;
cout<<sizeof(s)/sizeof(Person)<<endl;
return 0;
}
（2）属性列表中用到该结构体本身
#include <iostream>
using namespace std;
/*
方式三：用typedef给出别名，稍后再定义变量
(2) 属性列表中用到了该结构体本身
typedef struct StructName{
属性列表
}别名;
*/
typedef struct Person{
char *name;
int age;
double height;
//使用自身，例如配偶
struct Person *mate;
}Person, *PPerson;
void printPerson(Person p){
cout<<"姓名："<<p.name<<"， 年龄："<<p.age<<"， 身高："<<p.height<<endl;
cout<<"配偶姓名："<<p.mate->name<<"，配偶年龄："<<p.mate->age<<"，配偶身高："<<p.mate->height<<endl;
cout<<endl;
}
int main(){
Person lili, lihua;
//配偶
lili.mate = &lihua;
lihua.mate = &lili;
//信息
lili.name = "lili";
lili.height = 1.65;
lili.age = 23;
lihua.name = "lihua";
lihua.height = 1.78;
lihua.age = 25;
//打印p1的信息
printPerson(lili);
//打印p2的信息
printPerson(lihua);
return 0;
}
七、malloc free
malloc 开辟内存
定义：类型A *varName = (类型A *)malloc(字节数)
意义：表示创建对应字节数的空间，交给类型A的指针去管理
字节数：一般写为元素个数*sizeof(元素类型)
free 释放内存
定义：free（指针变量）
意义：用malloc申请的空间，不用的时候都要用free释放
可以创建动态的一、二维数组，但在数据结构中并不多用
使用malloc、free函数需要引入头文件：stdlib.h
数据结构中，主要还用于结构体的创建
#include <iostream>
//malloc、free
#include <stdlib.h>
using namespace std;
/*
malloc 开辟内存
定义：类型A *varName = (类型A *)malloc(字节数)
意义：表示创建对应字节数的空间，交给类型A的指针去管理
字节数：一般写为元素个数*sizeof(元素类型)
free 释放内存
定义：free（指针变量）
意义：用malloc申请的空间，不用的时候都要用free释放
可以创建动态的一、二维数组，但在数据结构中并不多用
使用malloc、free函数需要引入头文件：stdlib.h
数据结构中，主要还用于结构体的创建
*/
typedef struct{
int age;
double height;
}Person, *PPerson;
void printPerson(Person p){
cout<<p.age<<" , "<<p.height<<endl;
}
int main(){
//动态创建一个Person
//类型 *varname = (类型 *) malloc(字节数)
PPerson pperson = (Person *)malloc(sizeof(Person));
pperson->age = 10;
pperson->height = 1.85;
printPerson(*pperson);
//不使用，需要手动释放
free(pperson);
return 0;
}
八、三目运算符
三目运算符
A ? T : F
A：一个条件表达式，取值是true或false
当A为T时，返回结果T
当A为F时，返回结果F
注：C语言中0是false，其它都是true
#include <iostream>
using namespace std;
/*
三目运算符
A ? T : F
A：一个条件表达式，取值是true或false
当A为T时，返回结果T
当A为F时，返回结果F
注：C语言中0是false，其它都是true
*/
int main(){
int a = 1;
int b = a > 10 ? a : 10; //10
int c = a < 10 ? 0 : a; //0
cout<<b<<endl;
cout<<c<<endl;
int d = a ? 10 : -1; //10
a = -1;
int e = a ? 10: -1; //10
a = 0;
int f = a ? 10 : -1; //-1
cout<<d<<endl;
cout<<e<<endl;
cout<<f<<endl;
return 0;
}
九、递归
1）使用递归，分解、合并模型
2）结束条件
int 方法名(参数){
if(结束条件) return 返回值;
else{
return n * 方法名(n - 1);
}
}
例子：求n的阶乘
#include <iostream>
using namespace std;
//求n的阶乘
int fac(int n){
if(n == 1 || n == 0){
return 1;
}else{
int result = fac(n - 1);
return n * result;
}
}
int main(){
cout<< fac(3) << endl;
return 0;
}
十、动态数组
静态数组： int a[10];
代码运行时，静态数组长度一旦定义好就无法改变，容易造成浪费空间等问题。
动态数组：可以根据需要动态申请空间
定义： 类型 *varName = (类型 *)malloc(数组元素个数*单个元素所占字节数)
(类型 *) 强制类型转换，使用 类型指针接收这一块类型空间
#include <iostream>
#include <stdlib.h>
using namespace std;
void testStaticArray(){
int a[] = {1, 2, 3, 4, 5};
int sizeA = sizeof(a) / sizeof(int);
cout << "方式一访问静态数组" << endl;
for(int i = 0; i < sizeA; i++){
cout << a[i] << "\t";
}
cout << endl;
cout << "方式二访问静态数组" << endl;
int *b = a;
int count = 0;
while(count < sizeA){
cout << *b <<"\t";
b++;
count ++;
}
cout << endl;
}
void testDynamicArray(){
int sizeA = 5;
int *a = (int*)malloc(sizeA * sizeof(int));
cout << "方式一访问动态数组：赋值操作" << endl;
for(int i = 0; i < 5; i++){
a[i] = i + 1;
}
//数组名a：表示这个数组的首地址
cout << "方式二访问动态数组：" << endl;
int *b = a;
int count = 0;
while(count < sizeA){
//访问当前b指向位置上的值
cout << *b << "\t";
//去数组的下一位
b++;
count++;
}
cout << endl;
}
int main(){
testStaticArray();
testDynamicArray();
return 0;
}
十一、随机数
C或C++使用随机数，需要引入头文件 #include <time.h>
srand((unsigned)time(NULL)); 代码的作用：如果不设定随机时间，则获取的随机数不发生变化（底层为时间改变，随机指向某一数字地址，获取数字）
#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
int main(){
unsigned int n;
srand((unsigned)time(NULL));
cout << rand() % 6 + 1 << endl;
cout << rand() % 6 + 1 << endl;
for(int i = 0; i < 100; i++){
n = rand();
printf("%d\n", n % 6 + 1);
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
