C++基础快速学习笔记（一）

爱被打了一巴掌 2022-03-16 15:12 278阅读 0赞

## 1、命名空间 namespace ##

C++命名空间主要是为了解决命名冲突。

#include <iostream>
    // 命名空间主要是为了解决命名冲突
    // std 标准命名空间
    using namespace ::std;
    
    // 自定义命名空间
    namespace Graphics {
        int lib = 1.0;
        int x = 100;
    }
    
    namespace System {
        int lib = 2.0;
    }
    
    //嵌套命名
    namespace name1 {
        int alib = 4.0;
        namespace name2{
            int blib = 5.0;
        }
    }
    
    //一个项目组中使用一个命名空间
    using namespace System;
    int main(int argc, const char * argv[]) {
        // insert code here...
        cout << "Hello, World!\n";
        cout << lib << "\n\n";
        
        // 使用 Graphics 命名空间的 X
        using Graphics::x;
        cout << x + 100 << endl;
        
        using System::lib;
        lib = 3.0;
        cout << lib << endl;
        
        using namespace name1;
        cout << alib << endl;
        
        using namespace name1::name2;
        cout << blib << endl;
    
        return 0;
    }
    
    复制代码

## 2、引用和引用传递参数 ##

#include <iostream>
    using namespace ::std;
    int add(int a,int b){
        return a+b;
    }
    
    // 此处如果不是引用，或者指针，是 int a 那就是值拷贝，出了这个函数就还是原来的值
    void swap(int &X,int &Y){
        
        int temp;
        temp = X;
        X = Y;
        Y = temp;
    }
    
    
    int main(int argc, const char * argv[]) {
        // insert code here...
        std::cout << "Hello, World!\n";
        
        // C++
        // 按照值传递
        int sum = add(1, 2);
        
        // 引用传递：声明的时候必须初始化，一般作函数的形式参数
        
        int intOne;
        
        // 声明一个引用，并且初始化，指向同一个单元，是一个变量的别名
        // & 引用操作符，其他时候是地址操作符
        int& rint = intOne;
        
        intOne = 5;
        cout << rint << endl;
        
        rint = 7;
        
        // 引用发生改变，则都进行改变
        cout << intOne <<endl;
        cout << rint << endl;
        
        // 因为指针是相同的
        cout << &(intOne) << endl;
        cout << &(rint) << endl;
        
        
        // 引用 和 指针的区别
        
    //    1、指针是一个变量，可以重新给值指向别处
    //    2、建立引用过后必须初始化，不会再关联其他的变量
        
        // 也可以有指针变量的引用
        int* a = NULL;
        int* &rpa = a;
        cout << rpa <<endl;
        
        int b = 9;
        rpa = &b;
        cout << rpa <<endl;
        
        
    //    void &a 不合法 void本质上不是一个类型
    
        int arr[10] = {1,23};
        
    //    int &arrRpa = arr; 不能引用数组
    
    //    空指针无空引用
        int x = 100;
        int y = 200;
        swap(x, y);
        
    //    注意地方：
    //    1、函数智能返回一个值，解决这个问，可以返回引用
    //    2、不要在作用范围内返回一个局部作用域内的变量
        
        
        return 0;
    }
    
    复制代码

## 3、内联函数 ##

内联函数与宏定义

1、宏定义可以代替小型函数

2、宏定义只是更换代码，不检查参数类型

3、宏的作用可以用内联函代替

#define MAX(a,b) ((a)>(b)?(a):(b))
    #define square(x) ((x)*(x))
    
    inline int inlineMax(int a,int b){
        
        return a>b?a:b;
    }
    
    inline bool isnumber(char ch){
        
        return ((ch >= '0') && (ch <= '9'));
    }
    
    int main(int argc, const char * argv[]) {
        // insert code here...
        std::cout << "Hello, World!\n";
        
    //  函数调用：建立栈内存环境，进行参数传递，并产生程序执行转移。
        
    //  内联函数 inline ：为了减少函数调用成本，小型，频繁的函数
    //    注意：
    //    1、仅在开始前申明一次
    //    2、被调用之前被声明或定义，因为要替换之前的代码
    //    3、不能含有复杂结构，比如switch 和 while
    //    4、不能有递归
        
        char c;
        // 输入
        while ((c = cin.get()) != 'q') {
            
            // 打印两次是带有一个回车
            if (isnumber(c)){
                cout << "YES" <<endl;
            }else{
                cout << "NO" << endl;
            }
            
        }
        
        
        int num = square(2+3+1);
        
        // 36
        printf("-----%d\n",num);
        
        int a = 0;
        int b = 1;
        bool isbig = MAX(a++,b--);
        
        printf("-----%d",isbig);
        
        return 0;
    }
    
    
    复制代码

## 4、默认参数的函数 ##

int myfunc(int a,int b=1,int c=2);
    
    int main(int argc, const char * argv[]) {
        // insert code here...
        std::cout << "Hello, World!\n";
        
    //    1、调用函数不指定全部函数
    //    2、可以不指定的参数提供默认值
        
        int data = myfunc(12,12,12);
        
        printf("\n%d\n\n\n",data);
        
        return 0;
    }
    
    //默认参数：形参分布，从左到右逐渐定义
    int myfunc(int a,int b,int c){
        
        return a+b+c;
    }
    
    复制代码

## 5、函数模版 ##

函数模版 ：快速建立类型安全的类库集合和函数集合

泛型编程 ：独立于任何特定类型的方式编写代码，模版 template 是泛型编程的基础。主要的：STL (标准模版库) / Boost

// typename 是由编译器去推断是什么类型
    template <typename T>
    T abs(T x) {
        return x < 0 ? -x:x;
    }
    int main(int argc, const char * argv[]) {
    
        int n = 5;
        double n1 = -23.44;
        
        cout << abs(n) << endl;
        cout << abs(n1) << endl;
      
        
        return 0;
    }
    
    复制代码

## 6、函数重载 ##

函数重载：两个以上的函数，但形参个数或者类型不同，编译器自己去确定该调用那一个函数。

匹配顺序：

1、严格的匹配

2、内部寻求一个匹配

3、通过用户的转移寻求匹配，查出唯一的一组转换

double square(double x,int y){
        
        cout << __FILE__ <<"-------"<< __LINE__ <<"-------"<< __func__ <<endl;
        return x*y;
    }
    
    double square(double x){
        
        cout << __FILE__ <<"-------"<< __LINE__ <<"-------"<< __func__ <<endl;
        return x*x;
    }
    
    
    int square(int x){
        
        cout << __FILE__ <<"-------"<< __LINE__ <<"-------"<< __func__ <<endl;
        return x*x;
    }
    
    int main(int argc, const char * argv[]) {
        // insert code here...
        std::cout << "Hello, World!\n";
    
        square(100.22);
        
        square('a');
        
        square(1.224f);
        
        square(1.22, 3);
        
        return 0;
    }
    复制代码