C++ c++与C语言的区别（三目运算符，const修饰符）

//区别⑦：三目运算符（C++版本）
#include<iostream>
using namespace std;

//三目运算符 C语言返回变量的值 C++语言是返回变量本身

void main(){
    int a = 10;
    int b = 20;
    a < b ? a : b = 30;
    //C++中的三目运算符可直接返回变量本身，因此可以出现在程序的任何地方
    //注意：
    //三目运算符可能返回的值中如果有一个是常量值，则不能作为左值使用
    //(a < b ? 1 : b) = 30;
    system("pause");
}

//区别⑦：三目运算符（C语言版本）
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void main(){
    int a = 10;
    int b = 20;
    //a < b ? a : b = 30;  报错  error C2106: “=”: 左操作数必须为左值
    //详解： 在C语言中，a < b ? a : b这里返回的a是a的值，而不是a这个变量
    //常量是不可以做左值的
    //左值在c++中很重要，元素当左值的条件是这个元素必须存在内存空间（在寄存器中的值就没有内存空间）
    
    //在C语言中实现三目运算符返回变量
    *(a < b ? &a : &b) = 30;
    system("pause");
}

//区别⑧：const修饰符（C++版本）
#include<iostream>

using namespace std;

//Const优点（C语言 c++共有优点）
//合理的利用const，
//1指针做函数参数，可以有效的提高代码可读性，减少bug；
//2清楚的分清参数的输入和输出特性
//例子：
//int setTeacher_err( const Teacher *p)
//Const修改形参的时候，在利用形参不能修改指针所向的内存空间

struct Teacher{
    char myname[30];
    int age;
};

void PrintfA(Teacher const *pin/*in*/){
    //pin->age = 30;   
    //报错  error C3490: 由于正在通过常量对象访问“age”，因此无法对其进行修改
    pin = (Teacher *)0x1;
}

void PrintfB(Teacher * const pin/*in*/){
    //pin = (Teacher *)0x1;
    //报错 error C3892: “pin”: 不能给常量赋值
    pin->age = 30;
}

void PrintfC(Teacher * const * pin/*in*/){
    //pin->age = 30;
    //报错 error C2227: “->age”的左边必须指向类/结构/联合/泛型类型
    //pin = (Teacher *)0x1;
    //报错 error C2440: “=”: 无法从“Teacher *”转换为“Teacher *const *”
}

void fun1(){
#define N2 10
    const int bb = 10;
    printf("变量的值是：%d
", bb);
}

void fun2(){
    printf("变量的值是：%d
", N2);
    //printf("变量的值是：%d
", bb);  error C2065 : “bb” : 未声明的标识符
    //表明 #define宏定义与 const 修饰变量的作用域不同

    //关闭宏定义
#undef N2
    //#undef  后面不加参数  直接关闭所有的宏定义
    /*printf("变量的值是：%d
", N2);  error C2065 : “N2” : 未声明的标识符*/
}

void main(){
    //const int a;
    // error C2734: “a”: 如果不是外部的，则必须初始化常量对象
    const int a=10;
    int const b = 20;

    //C++语言的间接赋值（这与C语言不同）
    int *p1 = (int *)&a;
    *p1 = 11;
    printf("a=%d
", a);// 打印a=10
    printf("*p1=%d
", *p1);// 打印*p1=11
    printf("&a=%x
", &a);//打印 &a= d2f7e0
    printf("p1=%x
", p1);// 打印 p1= d2f7e0

    //详解 const int a=10;
    //在c++中，存在一个符号表，以键值对的形式存储 const 修饰的变量 和 变量的值，
    //当c++编译器编译到 const int a=10;  这句话的时候
    //c++编译器会在符号表创建一个键值对  key 是 变量 a， value 是 10；
    //当后面程序使用到 const修饰的 a变量 的时候  c++编译器会直接从 符号表里取 a的值
    //当c++编译器 检索代码时 发现存在 &a(对 const 修饰的 a 取地址 )的操作的时候
    //c++会隐式 为 &a 分配一个内存空间  并且将 10 存入到这个内存空间
    //当程序员 *p1 = 11; 修改 *(&a) 的值的时候  修改的是个隐式创建的内存空间里的值
    //不会修改符号表中 a的数据
    //c++编译器之所以这么设计 是因为 C语言支持 对const 修饰的变量 取地址  为了兼容C语言 才如此设计的
    /*注意：C++编译器虽然可能为const常量分配空间，但不会使用其存储空间中的值（即任何时候获取a的值都是10）。*/

    char arr[a] = { 0 };//C语言中 const 常量不可以定义数组
    char temparr[a+b] = { 0 };
    
#define N 10
    char arr2[N] = { 0 };

    //C++中的const常量类似于宏定义
    //const int c = 5; ≈ #define c 5
    //C++中的const常量在与宏定义不同
    //const常量是由编译器处理的，提供类型检查和作用域检查
    //宏定义由预处理器处理，单纯的文本替换


    system("pause");
}

//区别⑧：const修饰符（C版本）
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct _teacher{
    char myname[30];
    int age;
}Teacher;

void PrintfA(Teacher const *pin/*in*/){
    //pin->age = 30;   
    //报错 error C2166: 左值指定 const 对象
    pin = (Teacher *)0x1;
}

void PrintfB(Teacher * const pin/*in*/){
    //pin = (Teacher *)0x1;
    //报错 error C2166: 左值指定 const 对象
}

void PrintfC(Teacher * const * pin/*in*/){
    //pin->age = 30;
    //报错 error C2227: “->age”的左边必须指向类/结构/联合/泛型类型
    pin = (Teacher *)0x1;
    //警告 warning C4047: “=”:“Teacher *const *”与“Teacher *”的间接级别不同（这样C++不同）
}

void main(){
    const int a=10;
    //a = 1;// error C2166: 左值指定 const 对象

    //C语言的间接赋值
    int *p1 = &a;
    *p1 = 11;
    printf("a=%d
", a);//打印 a=11
    
    //int buf[a] = { 0 };
    //报错  error C2057: 应输入常量表达式

    //以上例子说明 在C语言中  const只是个伪常量 const变量是只读变量，有自己的存储空间

    system("pause");
}