C++基础语法

大学学的C++全部忘记完了，现在又得花时间把错过的东西找回来！

基础语法

命名空间

命名空间类似于Java中包，主要防止命名重复！

引入头文件

#include <stdlib.h>
#include <iostream>

标准命名空间(包含很多标准的定义)

using namespace std;

自定义命名空间

namespace NSP_A{
    int a = 9;
    struct Teacher{
        char name[20];
        int age;
    };
    struct Student{
        char name[20];
        int age;
    };
}

namespace NSP_B{
    int a = 12;
    //命名空间嵌套
    namespace NSP_C{
        int c = 90;     
    }
}

void main(){
//使用命名空间
//::访问修饰符
cout << NSP_A::a << endl;
cout << NSP_B::a << endl;

cout << NSP_B::NSP_C::c << endl;

//使用命名空间中的结构体
using NSP_A::Student;
Student t;
t.age = 90;

system("pause");
}

类定义

#define PI 3.14
class MyCircle{
//属性（共用权限访问修饰符）
private:
    double r;
    double s;
public:
    void setR(double r){
        this->r = r;
    }
    //获取面积
    double getS(){
        return PI * r * r;
    }
};

void main(){
    // 类声明
    MyCircle c1;
    c1.setR(4);
    cout << "圆的面积：" << c1.getS() << endl;
    system("pause");
}

布尔类型

if (isSingle){
}
else{
}

int a = 10, b = 20;
((a > b) ? a : b) = 30;
cout << b << endl;

system("pause");
}

引用

引用就是变量的别名，主要是作为函数的参数或返回值

void main(){
    int a = 10;
    //b就这个内存空间另外一个别名
    //& C++中的引用
    int &b = a; 
    cout << b << endl;
    system("pause");
}

//指针值交换
void swap_1(int *a, int *b){
    int c = 0;
    c = *a;
    *a = *b;
    *b = c;
}

//引用值交换
void swap_2(int &a, int &b){
    int c = 0;
    c = a;
    a = b;
    b = c;
}

void main(){
    int x = 10;
    int y = 20;

    printf("%d,%d\n",x,y);
    //swap_1(&x, &y);
    //a成了x的别名
    swap_2(x,y);
    printf("%d,%d\n", x, y);
    system("pause");
}

void main(){
    Teacher t;
    t.name = "Jason";
    t.age = 20;
    myprint(t);

    myprint2(&t);

    system("pause");
}


//指针的引用，代替二级指针
/*
struct Teacher{
    char* name;
    int age;
};

void getTeacher(Teacher **p){
    Teacher *tmp = (Teacher*)malloc(sizeof(Teacher));
    tmp->age = 20;
    *p = tmp;
}

//指针的引用，代替二级指针
//Teacher* &p = (Teacher * *p)
void getTeacher(Teacher* &p){
    p = (Teacher*)malloc(sizeof(Teacher));
    p->age = 20;
}

void main(){
    Teacher *t = NULL;
    getTeacher(&t);
    system("pause");
}

指针常量与常量指针

指针常量：指针的常量，不改变地址的指针，但是可以修改它指向的内容
常量指针：指向常量的指针，内容不能修改

void main(){
    int a = 2, b = 3;
    // 指针常量，不能修改指针的地址值，能修改指向的内容
    int *const p1 = &a;
    //p1 = &b;  //NO
    *p1 = 4;
    // 常量指针，修改地址，不能改内容
    const int *p2 = &a;
    p2 = &b;
    //*p2 = 9;  //NO
}

引用与指针的区别

1.单纯给变量取别名没有任何意义，作为函数参数传递，能保证参数传递过程中不产生副本
2.引用可以直接操作变量，指针要通过取值(*p)，间接操作变量，指针的可读性差

常引用，类似于java中final

void myprintf(const int &a){
    cout << a << endl;  
}

void main(){    

    //const int a;
    //引用必须要有值，不能为空
    //int &a = NULL;

    //常引用
    int a = 10, b = 9;
    const int &c = a;

    //字面量
    const int &d = 70;  
    //c = b;
    myprintf(c);
    system("pause");
}

引用的大小

struct Teacher{
    char name[20];
    int age;
};

void main(){
    Teacher t;

    Teacher &t1 = t;
    Teacher *p = &t;

    cout << sizeof(t1) << endl;
    cout << sizeof(p) << endl;
    system("pause");
}

函数默认参数

前面的参数设为默认参数，那么后面的也必须是默认参数
void myprint(int x, int y = 9, int z = 8){
cout << x << endl;
}

可变参数

void func(int i,...)
{
    //可变参数指针
    va_list args_p;
    //开始读取可变参数，i是最后一个固定参数
    va_start(args_p,i);
    int a = va_arg(args_p,int);
    char b = va_arg(args_p, char);
    int c = va_arg(args_p, int);
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    //结束
    va_end(args_p);
}

void main(){
    func(9,20,'b',30);

    system("pause");
}

//循环读取
/*
void func(int i,...)
{
    //可变参数指针
    va_list args_p;
    //开始读取可变参数，i是最后一个固定参数
    va_start(args_p,i);
    int value;
    while (1){
        value = va_arg(args_p,int);
        if (value <= 0){
            break;
        }
        cout << value << endl;
    }

    //结束
    va_end(args_p);
}

void main(){
    func(9, 20, 40, 30);

    system("pause");
}