学习C++这一篇就够了（基础篇）

#include <iostream>
using namespace std;

int main()
{
   cout << "hello C++" << endl;
   
   system("pause");
   return 0;
}

extern "C"
{
   #include <libjpeg.h>
}

//1、整型 
int a = 0; 
cout << "请给整型变量a赋值："<<endl; 
cin >> a; 
cout << "整型变量a = "<< a << endl; 

//2、实型（浮点型） 
float f = 3.14f; 
cout << "请给浮点型变量f赋值："<<endl; 
cin >> f; 
cout << "浮点型变量f = "<< f << endl; 

//3、字符型 
int ch = 'a'; 
cout << "请给字符型变量ch赋值："<<endl; 
cin >> ch; 
cout << "字符型变量ch = "<< ch << endl;

//4、字符串型 
#include<string> //记得加上字符串头文件 
string str = "hello"; 
cout << "请给字符串str赋值："<<endl; 
cin >> str; 
cout << "字符串str = "<< str << endl; 

//5、布尔型
bool flag = flase; 
cout << "请给布尔型flag赋值："<<endl; 
cin >> flag; 
cout << "布尔型flag = "<< flag << endl;

if（关系表达式/条件）
{
   满足条件后执行的语句体;
}

if（关系表达式/条件）
{
    满足条件后执行的语句体;
}
else
{
    不满足条件执行的语句体;
}

if（关系表达式1/条件1）
{
    满足条件1后执行的语句体;
}
else if（关系表达式2/条件2）
{
    满足条件2后执行的语句体;
}
else
{
    都不满足时执行的语句体;
}

if（关系表达式1/条件1）
{
    if（关系表达式2/条件2）
      {
         if（关系表达式3/条件3）
          {
              语句体;
          }
      }
}

switch（关系表达式）
{
    case 结果1：执行语句;
                 break;
    case 结果2：执行语句;
                 break;
    ···
    defaylt：执行语句;
                 break;
}

switch（关系表达式）
{
   case：结果1 ... 结果2: 执行语句;
                              break;
   case：结果1 ... 结果2: 执行语句;
                              break;
   default:执行语句;
              break;
}

while（循环条件）
{
    循环语句
}

do
{
循环语句；
}
while（循环条件）;

for（起始表达式; 条件表达式; 末尾循环体）
{
   循环语句；
}

goto 标记符;

标记符;

int arr[10] = {1,2,3,4,5,6,7,8,9,0};

1、获取数组在内存中的首地址
cout << "元素首地址:" << (int)arr << endl;
cout << "数组中第一个元素的地址:" << (int)&arr[0] << endl;
cout << "数组中第一个元素的地址:" << (int)&arr[1] << endl;

//2、可以统计整个数组在内存空间长度
cout << "获取数组内存空间长度:" << sizeof(arr) << endl;
cout << "每个元素所占的内存空间:" << sizeof(arr[n]) << endl;
cout << "数组的元素个数:" << sizeof(arr)/sizeof(arr[0]) << endl;

int arr[2][3] = { 
                   (1,2,3), 
                   (3,4,5)
                 };

// 1、获取二维数组在内存中的首地址
cout << "二维数组首地址" << arr << endl;
cout << "二维数组第一行地址" << arr[0] << endl;
cout << "二维数组第二行地址" << arr[1] << endl;

cout << "二维数组第一个元素地址" << &arr[0][0] << endl;
cout << "二维数组第二个元素地址" << &arr[0][1] << endl;

// 2、获取整个二维数组所占内存空间
cout << "二维数组大小：" << sizeof(arr) << endl;
cout << "二维数组一行大小：" << sizeof(arr[0]) << endl;
cout << "二维数组元素大小：" << sizeof(arr[0][0]) << endl;

cout << "二维数组行数：" << sizeof(arr)/sizeof(arr[0]) << endl;
cout << "二维数组列数：" << sizeof(arr[0])/sizeof(arr[0][0]) << endl;

返回值类型  函数名 （参数列表）
{
     函数体语句;

     return;
}

//1、有参有返
数据类型 函数名 （数据类型 变量）
{
   函数体;
   return x;
}

//2、有参无返
void 函数名（数据类型 变量）
{
    函数体;
}

//3、无参有返
数据类型 函数名（）
{
    函数体;
    return x;
}

//4、无参无返
void 函数名（）
{
    函数体;
}

int a = 10;
int *p;
p = &a;  
//用指针p保存变量a的地址信息

//这就是空指针，指向了NULL，用来给指针变量初始化用的，但是不允许访问
int *p = NULL;

*p = 1000； //错误，空指针不允许访问

int *p = NULL; //这是空指针，是合法的

int *p = (int *)0x1100;  //这是野指针，因为地址空间0x1100还没有申请。直接拿来用是非法的

const int *p1 = &a;
p1 = &b;   //正确，地址可变
*p1 = 100; //错误，数据不可变

int * const p2 = &a;
p2 = &b; //错误，地址不可变
*p2 = 100；//正确，数据可变

const int * const p3 = &a；
p3 = &b;    //错误，地址不可变
*p3 = 100； //错误，数据不可变

int arr[] = {0,1,2,3,4,5,6,7,8,9};
int *p = arr;   //指针指向数组首地址
P++;            //指针向前移动4个字节，指向数组第二个元素

void swap(int a,int b)
{
  int temp = a;;
  a = b;
  b = temp;
}

int main（）
{
  int a = 10;
  int b = 20;
  swap(a,b);
}

void swap(int *p1,int *p2)
{
  int temp = *p1;
  *P1 = *p2;
  *p2 = temp;
}

int main（）
{
  int a = 10;
  int b = 20;
  swap(&a,&b);
}

//定义学生这个结构体
struct Student
{
  //成员列表
  string name;
  int age;
  int score;  
}

int main()
{

   //创建1、struct  结构体名  变量名
   struct Student s1;
   s1.name = "张三";
   s1.age = 18;
   s1.scoer = 100;


  //创建2、struct  结构体名  变量名 = { 成员1，成员2 ··· }；
   struct Student s2 = {"张三"，18，100};
}

struct Student
{
  //成员列表
  string name;
  int age;
  int score;  
}s3;   //s3就是我们顺便创建的机构体变量

int main（）
{
  s3.name = "张三";
  s3.age = 18;
  s3.score = 100;
}

struct stduent
{
  string name;
  int age;
  int score;
}

int main()
{
  struct student arr[3] = 
  {
    {"张三",18,100},
    {"李四",19,80},
    {"王五",20,60}
  };
}

struct stduent
{
  string name;
  int age;
  int score;
}

int main()
{
  struct student s = {"张三",18,100};  
  struct student *p = &s;
  p->name = "李四";
  p->age = 20;
  p->score = 80;
}

struct student
{
  string name;   //学生名字
  int age;       //学生年龄
  int score;     //学生分数
}

struct teacher
{
  int id;          //老师教工编号
  string name;    //老师名字
  struct student stu; //子结构体 学生
}
int main()
{
  struct teacher t;
  t.id = 1000;
  t.name = "老王";
  t.stu.name = "张三";
  t.stu.score = 100;
}

struct student
{
  string name;   //学生名字
  int age;       //学生年龄
  int score;     //学生分数
}

void temp1(struct student s)    //值传递
{
  //访问结构体用“.”
  //形参不会改变实参
}

void temp2(struct student *p)    //地址传递
{
  //访问结构体用“->”
  //形参可以改变实参
}

int main()
{
  struct sutdent s;
  s.name = "张三";
  s.age = 18;
  s.score = 100;
  temp1(s);       //值传递调用
  temp2(&s);      //地址传递调用
}

enum state 
{
  ok;       // 没有赋值，默认为0
  failed;   // 没有赋值，默认上一个数+1，为1
  error;      // 没有赋值，默认上一个数+1，为2
}

enum state 
{
  ok = 10;       // 主动赋值为10
  failed = 20;   // 主动赋值为20
  error;      // 没有赋值，默认为+1，即21
}