C++学习总结

Posted 2022-12-10 祥云湾

C++命名空间（名字空间）

定义：

namespace Li  //小李的变量定义
    FILE fp = NULL;

namespace Han  //小韩的变量定义
    FILE fp = NULL

调用：

using Li :: fp;
fp = fopen("one.txt", "r");  //使用小李定义的变量 fp
Han :: fp = fopen("two.txt", "rb+");  //使用小韩定义的变量 fp

using namespace Li;
fp = fopen("one.txt", "r");  //使用小李定义的变量 fp
Han :: fp = fopen("two.txt", "rb+");  //使用小韩定义的变量 fp

如果命名空间 Li 中还定义了其他的变量，那么同样具有 fp 变量的效果。在 using 声明后，如果有未具体指定命名空间的变量产生了命名冲突，那么默认采用命名空间 Li 中的变量。

命名空间内部不仅可以声明或定义变量，对于其它能在命名空间以外声明或定义的名称，同样也都能在命名空间内部进行声明或定义，例如类、函数、typedef、#define 等都可以出现在命名空间中。

C++标准库和std命名空间

为了避免头文件重名，新版 C++ 库也对头文件的命名做了调整，去掉了后缀 .h ，所以老式 C++ 的 iostream.h 变成了 iostream ， fstream.h 变成了 fstream 。而对于原来C语言的头文件，也采用同样的方法，但在每个名字前还要添加一个 c 字母，所以C语言的 stdio.h 变成了 cstdio ， stdlib.h 变成了 cstdlib 。
----------------------------------------------------------华丽的分割线-------------------------------------------------------------
C++ 对 const 的处理少了读取内存的过程，优点是提高了程序执行效率，缺点是不能反映内存的变化，一旦 const 变量被修改，C++ 就不能取得最新的值。

有读者提出疑问，const 变量不是禁止被修改吗？对，这种说法没错！不过这只是语法层面上的限制，通过指针仍然可以修改。下面的代码演示了如何通过指针修改 const 变量：

#include <stdio.h>
int main()
    const int n = 10;
    int *p = (int*)&n;  //必须强制类型转换
    *p = 99;  //修改const变量的值
    printf("%d\\n", n);
    return 0;

注意， &n 得到的指针的类型是 const int * ，必须强制转换为 int * 后才能赋给 p，否则类型是不兼容的。 将代码放到.c文件中，以C语言的方式编译，运行结果为99。再将代码放到.cpp文件中，以C++的方式编译，运行结果就变成了10。这种差异正是由于C和C++对 const 的处理方式不同造成的。

C++ inline内联函数

为了消除函数调用的时空开销， C++ 提供一种提高效率的方法，即在编译时将函数调用处用函数体替换，类似于C语言中的宏展开。这种在函数调用处直接嵌入函数体的 函数称为 内联函数（Inline Function） ，又称 内嵌函数 或者 内置函数 。
指定内联函数的方法很简单，只需要在函数定义处增加  inline  关键字：

#include <iostream>
using namespace std;

//内联函数，交换两个数的值
inline void swap(int *a, int *b)
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;


int main()
    int m, n;
    cin>>m>>n;
    cout<<m<<", "<<n<<endl;
    swap(&m, &n);
    cout<<m<<", "<<n<<endl;

    return 0;

注意，要在函数定义处添加 inline 关键字，在函数声明处添加 inline 关键字虽然没有错，但这种做法是无效的，编译器会忽略函数声明处的 inline 关键字。 当函数比较复杂时，函数调用的时空开销可以忽略，大部分的 CPU 时间都会花费在执行函数体代码上，所以我们一般是将非常短小的函数声明为内联函数。
使用内联函数的缺点也是非常明显的，编译后的程序会存在多份相同的函数拷贝，如果被声明为内联函数的函数体非常大，那么编译后的程序体积也将会变得很大，所以再次强调，一般只将那些短小的、频繁调用的函数声明为内联函数。
由于内联函数比较短小，我们通常的做法是省略函数原型，将整个函数定义（包括函数头和函数体）放在本应该提供函数原型的地方。下面的例子是一个反面教材，这样的写法是不被推荐的：

#include <iostream>
using namespace std;
//声明内联函数（函数原型）
void swap1(int *a, int *b);  //也可以添加inline，但编译器会忽略
int main()
    int m, n;
    cin>>m>>n;
    cout<<m<<", "<<n<<endl;
    swap1(&m, &n);
    cout<<m<<", "<<n<<endl;
    return 0;

//定义内联函数（应该放在函数原型处）
inline void swap1(int *a, int *b)
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;

C++内联函数也可以用来代替宏

发生函数调用时，编译器会先对实参进行计算，再将计算的结果传递给形参，并且函数执行完毕后会得到一个值，而不是得到一个表达式，这和简单的字符串替换相比省去了很多麻烦， 所以在编写C++代码时我推荐使用内联函数来替换带参数的宏。
和宏一样，内联函数可以定义在头文件中（不用加 static 关键字），并且头文件被多次#include后也不会引发重复定义错误。这一点和非内联函数不同，非内联函数是禁止定义在头文件中的，它所在的头文件被多次#include后会引发重复定义错误。
可以看到内联函数主要有两个作用，一是消除函数调用时的开销，二是取代带参数的宏。不过我更倾向于后者，取代带参数的宏更能凸显内联函数存在的意义。

规范地使用C++内联函数

尽管大多数教科书中在函数声明和函数定义处都增加了 inline 关键字，但我认为 inline 关键字不应该出现在函数声明处。这个细节虽然不会影响函数的功能，但是体现了高质量 C++ 程序设计风格的一个基本原则：声明与定义不可混为一谈，用户没有必要、也不应该知道函数是否需要内联。

更为严格地说，内联函数不应该有声明，应该将函数定义放在本应该出现函数声明的地方，这是一种良好的编程风格。

C++函数的默认参数

在C++中，定义函数时可以给形参指定一个默认的值，这样调用函数时如果没有给这个形参赋值（没有对应的实参），那么就使用这个默认的值。也就是说，调用函数时可以省略有默认值的参数。如果用户指定了参数的值，那么就使用用户指定的值，否则使用参数的默认值。

所谓默认参数，指的是当函数调用中省略了实参时自动使用的一个值，这个值就是给形参指定的默认值。
C++规定，默认参数只能放在形参列表的最后，而且一旦为某个形参指定了默认值，那么它后面的所有形参都必须有默认值。实参和形参的传值是从左到右依次匹配的，默认参数的连续性是保证正确传参的前提。
除了函数定义，你也可以在函数声明处指定默认参数。不过当出现函数声明时情况会变得稍微复杂，有时候你可以在声明处和定义处同时指定默认参数，有时候你只能在声明处指定。

C++ 规定，在给定的作用域中只能指定一次默认参数。

为了说明问题，我们不妨对 main.cpp 中的代码稍作修改：

#include <iostream>
using namespace std;
//多次声明同一个函数
void func(int a, int b, int c = 36);
void func(int a, int b = 5, int c);
int main()
    func(99);
    return 0;

第一次声明时为 c 指定了默认值，第二次声明时为 b 指定了默认值；第二次声明是添加默认参数。需要提醒的是，第二次声明时不能再次给 c 指定默认参数，否则就是重复声明同一个默认参数。

C++函数重载

函数的重载的规则：

• 函数名称必须相同。
• 参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
• 函数的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以成为函数的重载。

参数列表不同包括参数的个数不同、类型不同或顺序不同，仅仅参数名称不同是不可以的。函数返回值也不能作为重载的依据。

C++ 是如何做到函数重载的

C++代码在编译时会根据参数列表对函数进行重命名，例如 void Swap(int a, int b) 会被重命名为 _Swap_int_int ， void Swap(float x, float y) 会被重命名为 _Swap_float_float 。当发生函数调用时，编译器会根据传入的实参去逐个匹配，以选择对应的函数，如果匹配失败，编译器就会报错，这叫做 重载决议（ Overload Resolution ） 。
从这个角度讲，函数重载仅仅是语法层面的，本质上它们还是不同的函数，占用不同的内存，入口地址也不一样。

C++类的定义和对象的创建

类是用户自定义的类型，如果程序中要用到类，必须提前说明，或者使用已存在的类（别人写好的类、标准库中的类等），C++语法本身并不提供现成的类的名称、结构和内容。

class Student
public:
    //成员变量
    char *name;
    int age;
    float score;
    //成员函数
    void say()
        cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
    
;

类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。

在创建对象时，class 关键字可要可不要，但是出于习惯我们通常会省略掉 class 关键字，例如：

class Student LiLei;  //正确
Student LiLei;  //同样正确

除了创建单个对象，还可以创建对象数组：

Student allStu[100];

学习总结

java第5章学习总结

Java Web学习总结（13）Listener监听器

Linux学习总结（二十九）系统日志

对C++初学者的学习建议

20145207 《Java程序设计》第5周学习总结