C++基础快速学习笔记（一）-CSDN博客

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;
}
复制代码