C++学习之路（1）

demo1.cpp

#include <stdio.h>
#include <cstdio>

// 命名空间的定义:定义一块命名空间，名字叫 NameA
namespace NameA
{
    // 原来全局空间可以做的事情，命名空间都可以做：定义变量、函数、宏、结构体、枚举....
    int g_a;

    int g_b;

    int add(int a, int b)
    {
        return a+b;
    }

    namespace AA {

        int g_c;
    }
}
namespace NameB
{
    int g_a;
    int sub(int a, int b)
    {
        return a-b;
    }
}

using namespace NameA;
int g_b;     // 全局的g_b

// 命名空间的使用
// 1、通过命名空间名字和 域解析符（::） 引用空间中的成员
int main1()
{
    NameA::g_a = 10;
    printf ("1+2 = %d\n", NameA::add(1,2));

    printf ("NameB::g_a = %d\n", NameB::g_a);

    return 0;
}

// 2、通过 using 声明来使用整个命名空间
// using 声明只在当前作用域有效
int main2()
{
    using namespace NameA;   // 开启命名空间NameA,之后使用NameA中的成员不用再加域解析符
    // using namespace NameB;
    g_a = 10;                         // 用的 NameA 的 g_a
    printf ("1+2 = %d\n", add(1,2));  // 使用的是 NameA 的add
    printf ("NameA::g_a = %d\n", NameA::g_a);
    printf ("NameB::g_a = %d\n", NameB::g_a);

    return 0;
}

// 3、通过 using 声明来使用命名空间中的某个成员
int main3()
{
    using NameA::add;   // 之后使用 NameA 的add 不需要再加域解析符
    printf ("1+2 = %d\n", add(1,2)); // 使用的是 NameA 的add
    // printf ("g_a = %d\n", g_a);
    return 0;
}

// 4、默认命名空间使用
int main()
{
    using namespace NameA;
    NameA::g_b = 10;

    // 默认命名空间成员直接用域解析符  ::  来引用
    ::g_b = 20;

    NameA::AA::g_c = 10;

    return 0;
}
 

 

demo2.cpp

// C++ 的标准输入输出头文件  input output stream
#include <iostream>

using namespace std;

// 标准输出
int main1()
{
    // cout 类似于 printf, 作用是往屏幕打印数据
    // 区别：cout 是个变量   printf 是个函数
    // << : 左移操作符 和 cout 结合后功能变了，可以理解为数据流向
    //      数据从右边流向左边
    // 右边是 字符串 左边是屏幕  ==>  字符串  -->  屏幕
    // endl 是一个换行
    // C中的转义字符在C++同样可以使用
    // cout 支持链式操作，数据流遵循先来后到的原则
    cout << "hello\nworld" << endl;

    // cout 可以自动识别变基础量类型
    int a    = 10;
    char c   = 'A';
    float f  = 1.2f;
    double d = 2.3;
    char *str= "hello world";

    cout << "a = " << a << endl;
    cout << "c = " << c << endl;
    cout << "f = " << f << endl;
    cout << "d = " << d << endl;
    cout << "str = " << str << endl;

    printf ("a = %d, c = %c\n", a, c);
    cout << "a = " << a << ", c = " << c << endl;

    return 0;
}

// 标准输入： cin
int main()
{
    int a;
    char c;
    float f;
    double d;
    char str[20];

    cin >> a >> c >> f >> d >> str;

    cout << "a = " << a << endl;
    cout << "c = " << c << endl;
    cout << "f = " << f << endl;
    cout << "d = " << d << endl;
    cout << "str = " << str << endl;

    // cout << "请输入一个整数：";
    // cin >> a;    // scanf ("%d", &a);
    //cout << a << endl;

    // 注意：cin cout 必须放到一行的最左边
    // "hello" >> cout;  错误

    return 0;
}

 

demo3.cpp

#include <iostream>

using namespace std;

int main1()
{
    register int a = 10;

    // 如果对一个寄存器变量进行 & 操作
    // 则变量将不在是一个寄存器变量，而是普通变量
    printf ("&a = %p\n", &a);

    return 0;
}

struct Student
{
    int id;
    char name[20];
};

int main2()
{
    struct Student s1;

    // C++ 认为结构体是一个新的类型，所以可以直接定义变量
    Student s2;

    return 0;
}

// 新增的bool 类型：只有两个值  true 和 false
// true(真) 的值是1  false（假） 的值是0
// 0 是假，  非 0都是真
int main3()
{
    bool b = true;
    cout << true  << endl;
    cout << false << endl;

    b = 2;

    cout << b << endl;
    b = b - 10;
    cout << b << endl;

    b = b - 1;
    cout << b << endl;

    return 0;
}

// bool类型和float类型与 0  进行比较
int main4()
{
    bool b = true;

    if (b) // 判断真
    {

    }

    if(!b) // 判断假
    {

    }

    // 浮点型数据和 0 比较需要精度
    float a = 0.00000001;
    if (a>-0.000001 && a < 0.000001)
    {

    }

    return 0;
}

// 三目运算符
int main()
{
    int a = 10;
    int b = 20;

    int c = (a>b ? a : b);

    // 三目运算符可以作为左值来使用
    // C++中三目运算符返回的是变量的空间
    (a>b ? a : b) = 100;
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;

    // 三目运算符作为左值使用的时候结果中不能存在常量
    // (a>b ? a : 20) = 100;

    return 0;
}
 

 

demo4.cpp

#include <iostream>

using namespace std;

// 1、函数的默认参数：
// 允许形参带一个默认的值，当函数调用的时候没给形参传值，使用默认的值
int add(int a, int b = 10)
{
    return a+b;
}

// 注意：
// 1、如果函数有一个参数有默认值，则该参数右边的所有参数都要有默认值
void func(int a, int b = 10, int c = 20)
{
}

// 2、给形参设置默认值的时候，函数声明和函数定义不能同时赋值
// void func1(int a, int b = 10);
void func1(int a, int b);
void func1(int a, int b = 10)
{
    cout << "b = " << b << endl;
}
int main1()
{
    cout << add(1) << endl;
    cout << add(1,2) << endl;

    func1(1);
    return 0;
}

// 2、 函数占位参数：形参只有类型，没有变量名
void func2(int a, int b, int)
{

}

struct AA
{
    int a : 10;
    int b : 4;
    int   : 8;
    int c : 10;
};

// 占位参数可以和默认参数一起使用
void func3(int a, int b, int = 0)
{

}

int main()
{
    func2(1, 2, 3);
    func3(1, 2);

    return 0;
}

 

 

demo5.cpp

#include <iostream>

using namespace std;

// 函数重载：同一个函数名，可以有多个不同的实现
void myPitnt(int a)
{
    printf ("a = %d\n", a);
}

void myPitnt(const char *pstr)
{
    printf ("str = %s\n", pstr);
}

// 函数重载的规则：
// 1、参数个数不同
// 2、参数类型不同
// 注意：返回值不能作为重载的判定条件
void myPitnt(int a, int b)
{
}

//int myPitnt(int a, int b)
//{
//}

// 函数指针：用重载函数给函数指针赋值的时候，要匹配函数指针的类型
typedef void (*PFUNC)(int);

int main()
{
    myPitnt(10);
    myPitnt("hello");

    PFUNC p = myPitnt;
    p(10);
   // p("hello");
   // p(10,20);

    return 0;
}