C到C++的升级

时间：2022-09-09 17:35:45

C++更强调语言实用性

1、所有变量都可以在需要使用时再定义

i

int c = 0;

for(int i=1; i<=3; i++)
{
for(int j=1; j<=3; j++)
           {
                  c += i * j;    
            }           

}

2、register关键字请求编译器将局部变量存储到寄存器中

-在C++中依然支持register关键字

-C++编译器有自己的优化方式

　　C语言中无法获取register变量的地址

　　C++中可以取得register变量的地址

C++中的register关键字

C++编译器发现程序中需要取register变量的地址时，register对变量的声明变得无效。

 早期C语言编译器不会对代码进行优化，因此register变量是一个很好的补充

 

3、在C语言中，重复定义多个同名变量的全局变量是合法的，C语言中多个同名全局变量最终会被链接到全局数据区的同一个地址空间上。

在C++中，不允许定义多个同名的全局变量

4、struct关键字的加强

-C语言中struct定义了一组变量的集合

-C语言中struct定义的标识符并不是一种新的类型

-C++中的struct用于定义一个全新的类型

 

5、void f() 和 void f(void)有什么不同？

　　C++中所有的标识符都必须显示的声明类型

     C语言中的默认类型在C++中是不合法的

在C语言中：

int f()表示返回值为int，接受任意参数的函数

f(void)表示返回值为int的无参函数

在C++中

int f()和 int f(void)具有相同意义

表示返回值为int的无参函数

 

C++ 的布尔类型

bool的值有true和false

 

C++对三目运算符的改动

C++的三目运算符可以作为左值来使用，因为C++里的三目运算符返回的可能是引用

三目运算可能返回的有常量时，返回的是值。

C到C++的升级

 

C++中对const的升级

当碰到const声明时，C++编译器在符号表中放入常量，当需要使用常量时，直接以符号表中的值替换；

 

为了兼容c语言，编译器当碰到以下情况时，会给对应的常量分配存储空间；

对const常量使用了extern

对const常量取地址，使用&操作符；

注意：C++编译器虽然会为常量分配空间，但是不会使用其存储空间的值，都是用符号表中的值；

const int c = 5; ≈ #define c 5

const定义的 常量经过编译器处理，检查作用域等等，#define经过预处理器处理 只是文本替换

#include <stdio.h>

void f()

{

　　#define a 3

    const int b = 4;

}

void g()

{

printf("a = %d\n", a);

//printf("b = %d\n", b);

}

int main()

{

　　const int A = 1;

　　const int B = 2;

　　int array[A + B] = {0};

　　int i = 0;

　　for(i=0; i<(A + B); i++)

　　{

　　　　printf("array[%d] = %d\n", i, array[i]);

　　}

　　f();

　　g();

　　return 0;

}

这里的第19行int array[A + B] = {0};  在C语言中会报错，C++中不报错，

 

这里深度研究一下：const什么时候时只读变量，什么时候是常量？

const常量判断准则：

只有用字面量初始化的const常量才会进入符号表；

使用其他变量初始化的const常量仍然是只读变量；

被volatile修饰的const常量不会进入符号表；（换句话说，这里volatile修饰的const常量只是不能放在赋值符号的左边，不会进入符号表；也属于在编译期间不能直接确定初始值）

总结：在编译期间不能直接确定初始值的const标识符；都被作为只读变量处理；

 

const引用的类型和初始化变量的类型相同的时候：初始化变量成为只读变量；

const引用的类型和初始化变量的类型不相同的时候：生成一个新的只读变量；

 

#include<stdio.h>

int main(int argc, char **argv)
{
const int x = 1;
const int& rx = x; // rx -> readonly variable  
int& nrx = const_cast<int&>(rx);
    nrx = 5;
    printf("x = %d\n", x);
    printf("rx = %d\n", rx);
    printf("nrx = %d\n", nrx);

    printf("&x = %p\n", &x);
    printf("&rx = %p\n", &rx);
    printf("&nrx = %p\n", &nrx);

volatile const int y = 2;
int* p = const_cast<int*>(&y);
*p = 6;
    printf("y = %d\n", y);
    printf("p = %p\n", p);

const int z = y;
     p = const_cast<int*>(&z);
*p = 7;    
    printf("z = %d\n", z);
    printf("p = %p\n", p);

char c = 'c';
char &rc = c;
const int& trc = c;
    rc = 'a';
    printf("c = %c\n", c);
    printf("rc = %c\n", rc);
    printf("trc = %c\n", trc);

return 0;
}
// Type* const name; -> int& name;
x = 1
rx = 5
nrx = 5
&x = 0xbf90ab44
&rx = 0xbf90ab44
&nrx = 0xbf90ab44
y = 6
p = 0xbf90ab40
z = 7
p = 0xbf90ab3c
c = a
rc = a
trc = c

 

标签：

相关文章