c++教程基础一

lijunsun
122 阅读2分钟

常量

1.常量分宏常量和装饰常量
#define宏常量：#define 常量名 常量值
const修饰的变量：const数据类型 常量名=常量值

example:
#define Day 7	//一周有7天
const int day=12;

c++关键字

标识符命令规则：、

1.标识符不能是关键字
2.标识符只能由字母，数字，下划线组成
3.第一个必须是字母或者下划线
4.标识符区分大小写

数据类型

1.整型：
数据类型 变量名 = 变量初始值,short,int,long,long long
int a = 10;
2.浮点型：
单精度float
float f = 1.14f;	// 默认情况下小数点是double
double f = 1.12;
双精度double
3.sizeof关键字：
cout << "short 类型所占内存空间："<<sizeof(short)<<endl;
4.科学计算法：
float f = 3e2; //3*10^2
float f = 3e-2;	// 3*10^-2

字符型：

char ch = 'a'; // 字符变量只占用1个字节
字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII
编码放入存储单元
in main(){
	char ch = 'a';
    cout << ch <<endl;
    cout << sizeof(char)<<endl;
    
}

char ch = 'a';
cout << ch << endl;
sizeof(char);

cout <<int(ch)<<endl;	// 强制性转换：把ASCII转化成整形

字符串

char 变量名[] = "字符串值";
char str[] = "Hello world！";
string str = "hello world";
cout <<str<<endl;	// 需要导入头文件 #include <string>

布尔类型：

int main(){
	bool flag =true;
    cout << flag <<endl;	//1	1代表真，0代表假
    cout <<sizeof(bool)<<endl;
}

数据的输入:

cin >> 变量
{
	//1.整型，2.浮点型，3.字符串型，4.布尔型
    int a = 0;
    cout << "请给整形变形a赋值："<<endl;
    cin >>a;
    bool flag = true;
    cin >> flag;
    cout << flag <<endl;
}

运算符：

+-*/
%:取余数
++

比较运算符：

==,!=,<,>,<=,>=

逻辑运算符

!：非，&&:与，||:或

程序流程结构：

1.选择结构：
三目运算符： 表达式?表达式1:表达式2; a>b?a:b;
switch(表达式)
{
	case 结果1: 执行语句;break;
    case 结果2: 执行语句;break;
    ...
    default:执行语句;break;
}
2.循环结构：
// 添加随机种子，，作用当前系统时间生成随机数，防止每次随机数都一样
#include <ctime>
srand(unsigned int)time(NULL);
while(循环条件){循环语句}
产生随机数：
rand()%100	就生成0--99之间的随机数
while(1){
break;	// 可以用break退出循环
}
do...while循环语句
作用：满足循环条件，执行循环语句
语法：do{循环语句} while(循环条件);
先执行一次，在判断条件

for循环语句：
for(起始表达式;条件表达式;末尾循环体){循环语句}
{
	// 从数字0打印到数字9
	for(int i = 0; i<100; i++){
    	cout <<i << endl;
    }
}

跳转语句：

1.break语句：退出循环
2.continue:执行到本行就不再执行后面的代码了，而继续执行下一轮循环
{
	for(int i=0; i<=100; i++){
    	if(i%2==0){
        	continue;
        }
        cout <<i<<endl;
    }
}

3.goto:无条件跳转语句
{
	goto FLAG;
    FLAG:
    // 尽量不用
}

数组：

一维数组：
数据类型 数组名[数组长度];
数据类型 数组名[]={值1，值2，值3...};
数据类型 数组名[数组长度]={数据1，数据2};
arr[0] arr[1] 
sizeof(arr)
数组名是常量，不可以进行赋值操作

example：
{
	int arr[] = {300,350,200,400,250};
    int max = 0;
    for(int i=0;i<5;i++){
    	if(max<arr[1]){
        	max = arr[i]
        }
    }
    cout<<max<<endl;
}
int start=0;
int end=sizeof(arr)/sizeof(arr[0])-1; // 末尾元素下标
二维数组：
数据类型 数组名[行数][列数] = {{值1，值2，值3...},{值1,值2,值3,..}};

函数：

返回值类型 函数名 参数列表
{
	函数体语句
    return 表达式
}
example：
int add(int num1,int num2){
	int num = num1+num2;
    return num;
}

值传递：
void swap(int num1, int num2){
	// void不需要写return
    cout << "交换前："<<endl;
}

函数的常见样式：
提前告诉编译器函数存在：
int max(int a, int b);	// 函数的声明

函数的分文件编写：
1.创建后缀名为.h的头文件
2.创建后缀名尾.cpp的源文件
3.在头文件中写函数的声明
4.在源文件中写函数的定义

指针

指针的作用：可以通过指针间距访问内存
1.内存编号从0开始记录的，一般就用十六进制数字表达
2.可以利用指针变量保存地址
定义指针: 数据类型 *指针变量名;
int a = 10;
int *p;
// 让指针记录变量a的地址
p = &a;
cout << "a的地址为:"<<&a<<endl;
cout <<"指针p为："<<p<<endl;
使用指针：指针前面+*代表解引用，
*p = 100;


使用指针
{
	int a = 10;   
}

指针所占内存空间：
int *p;		//在64位中占用8位字节，32位占4位字节
int a=10;
int *p = &a;
cout<<sizeof(p);

空指针和野指针
用途：初始化指针变量
：空指针指向的内存是不可以访问的
野指针：

int *p = NULL;
{
	int *p = NULL;
    野指针：在我们重新种避免出现野指针
    int *p = ;
    
}

const修饰在指针：
const修饰指针：--常量指针
const int *p = &a	:常量指针
特点：指针的指向可以修改，但是指针指向的值不可以改
int * const p = &a;指针常量
特点：指针的指向不可以改，指针指向的值可以改
cont int * const p3=&a;

指针和数组：
int arr[]={1,2,3,4,5,6,7,8,9,10};
int *p = arr;	//指向数组，数组不需要&前缀数组名就是数组的首地址
p++;

指针和函数：
{
	void swap(int a, int b){
		int temp = a;
        a=b;
        b=temp;
    }
    
    void swap02(int *p, int *p2){
    	int temp = *p;
        *p1=*p2;
        *p2=temp;
    }
    int main(){
    	swap(a,b);
    	swap2(&a,&b)
        return 0;
    }
}

指针，数组，函数
void bubleSort(int *arr,int len){
	for(int i=0;i<len-1;i++){
    	for(int j;j<len-i-1;j++){
        	if(arr[j]>arr[j+1]){
            	int temp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}

printArray(int *arr,int len){
	for(int i=0;i<len;i++){
    	cout<<arr[i]<<endl;
    }
}

int main(){
	//1.先创建数组
    //2.打开函数，实现冒泡排序
    //3.打印排序后的数组
    int arr[10]={14,2,5,6,9,8,4,3,5,0};
    int len=sizeof(arr)/sizeof(arr[0])
    bubbleSort(arr,len);
}

结构体：

结构体属于以后自定义数据类型，允许存储不同的数据类型
语法：struct 结构体名 {结构体成员列表};
通过结构体创建变量的方式有三种：
1.struct 结构体名 变量名
2.struct 结构体名 变量名={成员1值，成员2值...}
3.定义结构体时顺便创建变量
注：结构体创建变量的时候可以省略struct 比如：结构体名 变量名; Student s4;
struct Student{
	// 成员列表
    string name;	// 姓名
    int age;	// 年龄
    int score;	// 分数
}
// 通过学生类型创建具体学生
1.struct Student s1;	s1.name="张三"; s1.age=....
2.struct Student s2={"张三",18,80};
3.struct Student{
	string name;
    int age;
    int score;
}s3;	// 直接创建一个变量	结构体变量在c++中struct可以省略

结构体数组：结构体名 数组名[元素个数] = {{},{}...};
struct Student{
	//姓名
    string name;
    //年龄
    int age;
    //分数
    int score
};

struct Student stuArray[8]={
	{"name1","age1","score1"},
    {"name2","age2","score2"}
    ...
}

结构体指针：利用操作符号->可以通过结构指针访问结构体属性
{
	struct Student{
    	string name;	//姓名
        int age;	// 年龄
        int score;	// 分数
        
        
    };
    int main(){
    	
    	//1.创建学生结构体变量
        struct Student s = {"张三",18,100};
        //2.通过指针指向结构体变量
        struct Student *p = &s;
        //3.通过指针访问结构体变量中的数据
        p->name
        cout<<p->name<<endl;
    }
}

结构体嵌套结构体
// 老师的结构体
struct student{
	string name;
    int age;
    int score;
};
struct teacher{
	int id;
    string name;
    int age;
    struct student stu;		// 学生的结构体   
};
// 学生的结构体
int main(){
	teacher t;	//struct可以省略
    t.id = 10000;
    t.name = "老王";
    t.age = 50;
    t.stu.name = 20;
}

// 结构体做函数参数：
值传递
struct student{
	string name;
    int age;
    int score;
}

void printStudent(struct student s){	// 值传递
	cout <<s.name<<s.age<<endl;
};
值传递：printStudent(s)

//	1.值传递	2.地址传递
void printStudent(struct student *p){	//类型就是struct 结构体名
	cout<<p->name<<endl;
}
printStudent(&s);

结构体中const使用场景：
结构体中const使用场景
struct student{
	string name;
    int age;
    int score;
};
void printStudents(const student *s){//将函数中的形成改成指针，可以减少内存空间，而且不会复制新的副本出来,加入const就不能修改就可以了常量指针
	s->age = 150;
	cout <<"姓名："<<s.name<<"年龄："<<s.age<<endl;
}

int main(){
	struct student s = {"张三",15,70};
    // 通过函数打印结构体变量的信息
    printStudents(&s);
}
example：
结构体案例：
struct Student{
	string sName;
    int score;
}
struct Teacher{
	string tName;
    // 学生数组
    struct Student sArray[5];	// 一个老师5个学生
}

void allocateSpace(struct Teacher tArray[]. int len){	// 传数组或者指针
	string nameSeed = "ABCDE";
	for(int i = 0;i<len;i++){
    	tArray[i].tName="Teacher_";
        tArray[i].tName += nameSeed[i];
        for(int j=0;j<5,j++){
        	tArray[i].sArray[j].sName = "Stdudent_";
            tArray[i].sArray.sName += nameSeed[j];
        }
    }
	
}

int main(){
	struct Teacher tArray[3];
    int len=sizeof(tArray)/sizeof(tArray[0]);
 	allocateSpace(tArray,len);   
}

system("pause");	//按任意键继续
system("cls");	// 清理内存
avatar
文章
阅读
粉丝