C++学习笔记！
这是刚开始写的文件，后来发现太大不合适就开始分开写了
#include<iostream>
#include<string>//c++风格字符串头文价
//下面是定义宏常量：宏常量一旦定下，下文就不能修改了
#define day 7
using namespace std;
int add(int a, int b)
{
int sum = a + b;
return sum;//即最终函数的值为sum，就相当于y
}
int main()
{
//这是单行注释
/*这是多行注释，可以将多行的信息变为注释*/
/*main是一个函数的入口
每个程序有且仅有一个main函数
*/
cout << "hello C++" << endl;
cout << "一周总共有" << day << "天" << endl;
int a = 10;//与c语言一致，这就是创建变量
cout << "a=" << a << endl;
//如果我用int函数，则变量值是可修改的，但用了const就不行了
int b= 5;
b = 6;
cout << b << endl;
short t = 1;//短整型（-32768~32767）
int w = 2;//整型（-2^31---2^31-1)
long z = 3;//长整型(数的范围与整型一致）
long long f = 4;//长长整型（-2^63----2^63-1)
//float 4字节，doule 8字节
cout << sizeof(f) << endl;//利用sizeof求出数据占用内存
cout << f << endl;
char ch = 'a';
cout << (int)ch << endl;//输出字符的大小
cout << "//" << endl;//与c语言一致，需要加个/来输出后面的/
/*“/t”水平制表符，占8个空间，aaa/t则输出aaa加八个空格
，aaaaa/t则输出aaaaa加三个空格*/
cout << "aaa\tHello,world" << endl;
cout << "aaaaa\tHello,world" << endl;
//接下来是字符串 C语言风格
char str[] = "hello,world";//注意要有[]，这标志这是字符串，同时用“”
//接下来是c++风格字符串（需要先设头文件）见开头
string str2 = "hello,world";
cout << str2 << endl;
//bool类型判断真假
bool flag = true;//输出1
cout << flag << endl;
flag = false;
cout << flag << endl;
/*cout << b << endl;
cout << a+b<< endl;*/
/*const int c = 12;
c = 13;*/
//上面这行就会报错！！
/*数据类型（eg.整型，字符型···）类型不同，对变量
的内存也不同*/
//利用cin>>来从键盘上输入数据
//在c++中，两个整数相除，结果为整数（取整）eg.10/3=3
//两个小数无法做取余运算
//a%=b<==>a=a%b
int j = 0;
cin >> j;
cout << j << endl;
//以下是多条件if语句：
/*接下来是我写的一个例子：
输入高考分数，如果大于600，输出“考上一本大学”，如果大于五百
，则输出考上二本大学，如果大于400，输出考上三本大学，否则，
输出未考上！*/
cout << "请输入高考分数" << endl;
int i = 0;
cin >> i;
if (i > 600)
{
cout << "考上一本大学" << endl;//如果不满足i > 600,则执行下一个else if
}
else if (i > 500)
{
cout << "考上二本大学" << endl;//如果不满足，继续往下执行
}
else if (i > 400)
{
cout << "考上三本大学" << endl;//如果都不满足，则执行else
}
else
{
cout << "你没考上大学" << endl;
}
//项目练习：三只小猪称体重
//猜数字
//找水仙花数
int arr1[];//注意：定义数组时，应有长度，像这个就会报错(不允许使用不完整的类型）
int arr2[] = { 1,2,3.4 };//这个就没问题
cout<< (int)arr2 << endl;//这样输出arr2的地址
cout << (int)arr2[0] << endl;//与上相同
/*数组的地址与数组第一个元素的地址相同*/
cout << sizeof(arr2) << endl;//arr2的大小
//数组名是常量，不能修改，即：arr2 = 100；这样是不对的
/*二位数组的四种定义方式：
1.数据类型 数组名[行数][列数]；
2.数据类型 数组名[行数][列数]={{数据1，数据2}，{数据3，数据4}}；
3.数据类型 数组名[行数][列数]={数据1，数据2，数据3，数据4}（利用给出
行数列数电脑自动分配）
4.数据类型 数组名[ ][列数]={数据1，数据2，数据3，数据4}；
*/
//二维数组查看占用内存大小：
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << sizeof(arr) << endl;//查看数组占用内存大小
cout << sizeof(arr[0]) << endl;//查看第一行占用内存
cout << sizeof(arr[0][0]) << endl;//第一个数据算占用内存
cout << arr << endl;//查看数组的首地址，即第一行的地址，及第一个数据的首地址
//接下来是函数
/*返回值类型 函数名 （参数列表）
* int add （int num1，int num2）
* {
*
* 函数体语句
*
*
* return表达式
*
* }
*
*/
//例如max函数，可以见typora笔记
system("pause");//这是按任意键继续的功能
int a = 10;
int b = 20;
//a和b在上面确实出现了，下面函数用到了，因此被称为 实际参数，简称实参
//而在函数定义的时候，num1，num2并没有真实的数据，只是形式上的参数，因此被称为形参
//当调用函数时，实参的值会传递给形参
int c = add(a, b);
return 0;
//值传递建一个新的c++例子
//函数的几种常见的样式：看新文件
}
//
接下来是函数
#include<iostream>
using namespace std;
//函数的分文件编写见新文件
//接下来介绍函数的几种常见样式：
//1.无参无返
void test01()
{
//void a = 10;这样会报错，无类型不可以创建变量，原因无法分配内存
cout << "this is test01" << endl;
//test01();函数调用
}
//2.有参无返
void test02(int a)
{
cout << "this is test02 a=" << a << endl;
//调用时的注意事项见后
}
//3.无参有返
int test03()
{
cout << "this is test03" << endl;
return 1000;//test03的值变为1000
}
//4.有参有反
int max(int a, int b)
{
if (a > b)
return a;
else
return b;
//下面是个简单写法
// return a>b? a:b;
}
//接下来是函数的声明
//在这先声明一个函数，然后把自己写的这个函数放在最后
int min(int a, int b);
//声明可以写多次，但定义只能写一次，如下：
int min(int a, int b);
int min(int a, int b);
int min(int a, int b);
int main()
{
//接下来是函数的调用
//1。
test01();
//2.
test02(100);//这时候就要给这个形参赋值了
//3.
int num1 = test03();
cout << "num1 = " << num1 << endl;
//4.
int a, b, c;
a = 1;b = 2;
c = max(a, b);
cout << c << endl;
system("pause");
return 0;
}
//在这写min函数
int min(int a, int b)
{
if (a > b)
return b;
else
return a;
}
形参与实参的了解
#include<iostream>
using namespace std;
//接下来做个交换函数，讲个值传递的例子
void swap(int num1, int num2)//不需要返回某个值时，即最终不需要输出什
//可以利用void，这样就不用写return；了
{
cout << "交换前" << endl;
cout << "num1=" <<num1<< endl;
cout << "num2=" << num2<<endl;
int temp = num1;
num1 = num2;
num2 = temp;
cout << "交换后" << endl;
cout << "num1=" <<num1<< endl;
cout << "num2=" << num2<<endl;
}
int main()
{
int a = 10;
int b = 20;
cout << "a=" << a << endl;
cout << "b=" << b << endl;
//注意输出结果，当我们做值传递时，函数的形参发生改变，并不会影响实参
//即最后a还是a，b还是b，值并不会发生改变
swap(a, b);
cout << "a=" << a << endl;
cout << "b=" << b << endl;
system("pause");
return 0;
}
接下来是函数的分文件编写
接下来是指针
#include<iostream>
using namespace std;
void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
//地址传递：通过形参改变实参a，b的值
void swap02(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
/*
* 用指针，即通过指针来改变对应地址里的值，进而真正改变a，b中所存的值
* 这的实参是指针，因此只是指针所指的地址没有发生改变
*/
}
int main()
{
//接下来是指针
//指针的占用字节大小确定，在32位系统中为4个字节，在64位系统中为8字节
//这个64为系统环境与32为系统环境，可在上方本地windows调试器左边的x64（64位），x86（32位）里选
int a = 0;
int b = 2;
int* p = &a;//int *p,即为定义整型指针，&为取地址符，指针就是地址
//指针同样包含值与地址两部分
*p = 1000;//这是通过指针直接对其所对应的地址上的值进行修改，* 为 解引用
cout << *p << endl;
//下面是空指针
int* p1 = NULL; //指针变量指向内存地址编号为0的空间
//这就是初始化指针 注：空指针指向的内存是不可以访问的
//原因：0~255内存编号是系统占用的，因此不可以访问（不能对其修改：eg. *p1 = 1000；）
//接下来是野指针
//指 指针变量指向非法的内存空间
//int* p2 = 0x1100; //这样会报错，0x1100是个具体的数，不是个地址，要修改为地址有以下操作
//int* p2 = (int*)0x1100; //这就是指向一个地址 随便拿一指针指向随便一个地址，无法访问
// cout << *p2 << endl; //这叫读取访问权限冲突
//const修饰指针 ----常量指针：指针的指向可以修改，但是指针指向的常量无法修改
const int* p3 = &a;
p3 = &b;//可以这样改，但不能*p3 = 23
//const修饰变量 ====指针常量 ：指针指向不可改，但其指向的值可修改
int* const p4 = &a;//这就是指针常量，注意事项不再赘述
//const既修饰指针，又修饰常量
const int* const p5 = &a;//这是指向和指向的量都不能修改的
//*： 指针 const： 常量
//记法：const *，（*为常量）则*p = ··这种操作无法进行 *const p，则 p = &a 这种操作无法进行
//接下来是 指针与数组
int arr[10] = { 1,2.3,4,5,6,7,8,9,10 };
cout << "The first element is:" << arr[0] << endl;
int* p6 = arr;//arr就是数组首地址 = &arr[0]
cout << "using pointer to the first element:" << *p6 << endl;
p6++; //对指针进行加减是对其指向的元素类型进行加减。计算单位不是字节，是其指向的元素类型
//p++,p--,p+i,p-i,p+=i,p-=i;
//若p1与p2指向同一数组，则p1-p2 = 两指针间元素个数 <=> （p1-p2）/d
//p1+p2 无意义
// 一维数组万能公式： a[i] = *（a+i） 因此有 a[3] = *(a+3) = *(3+a) = 3[a] 这个公式很攒劲
cout << "using pointer to the second element:" << *p6 << endl;
//下面是指针与函数 地址传递
// 以c语言为例
/*
// #include<stdio.h>
#define SIZE 5
void change(int a[5]) //这个地方传递的是数组首地址，不是数组
{ //a[5] 可以写成*a,因为它本身就是个地址！
a[3] = 100; //这个a[3]本质上也是个地址，利用全能公式可以得到
}
int main()
{
int a[SIZE], i;
for (i = 0;i < SIZE;i++)
a[i] = i + 1;
change(a);
for (i = 0;i < SIZE;i++)
printf("%d\t", a[i]);
return 0;
}
*/
//int *p;
//p[i] = *(p+i)
//&p[i] = &(*(p+i)) 万能公式
// = p+i
//将形参中的改变的值带给实参中
//见 swap02函数
system("pause");
return 0;
}
#include<iostream>
using namespace std;
///*冒泡法排序：
// 1.比较相邻的两个元素，如果第一个大于第二个，则交换他们两个
// 2.对每一对相邻元素做同样的工作，执行完毕后，找出一个最大值
// 3.重复以上的步骤，每次比较次数-1，直到不需要比较*/
//
//int arr[] = { 4,2,8,0,5,7,1,3,9 };
//int i;
//for (int j = 0;j < 9;j++)
//{
// cout << arr[j] << endl;
//}
//cout << endl;
//for (int h = 0;h < 8;h++) {
//
// for (i = 0;i < 8;i++)//只写着一个循环的话第一个与第二个
// //换，第二个与第三个换，第三个与第四个换，但第二个
// //就不会与第三个比较了，因此要从头再重新比较一遍！
// {
// int temp = 0;
// if (arr[i] > arr[i + 1])
// {
// temp = arr[i + 1];
// arr[i + 1] = arr[i];
// arr[i] = temp;
// }
// }
//}
//for (int j = 0;j < 9;j++)
//{
// cout << arr[j] << endl;
//冒泡排序函数
void bubble_sort(int* arr, int len)//这就是 指针数组 这个概念了，arr[i]在这为指针数组，对应每一项的地址
{
for (int i = 0; i < len; i++)
{
for(int j = 0;j<len-i-1;j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
//打印函数
void print_array(int* arr, int len)
{
for (int i = 0;i < len;i++)
{
cout << arr[i] << endl;
}
}
int main()
{
int arr[10] = { 2,5,6,3,7,0,8,4,1,9 };
bubble_sort(arr, 10);
print_array(arr, 10);
system("pause");
return 0;
}
这就是目前学到了，这两天身体长病不舒服，没使劲学...
感谢战队让我进步飞快。尤其感谢战队里大佬们及身边同学们的不断支持与鼓励，感谢他们让我在极短的时间里了解到如此多的课堂上不会讲的知识，这是我受益匪浅，并且我乐意将知识不断分享给周边许多人！