C++基础学习笔记 day02

 1. 作业案例：设计圆类

#include 
using namespace std;

const double pi = 3.14;

// 1. 设置一个类，求圆的周长
// 周长公式：2*pi*r 
class Circle // Class代表声明一个类 后面紧跟的是类的名称
{
public: // 公共权限

        // 在类里面写函数 成员函数
        double calculateZC()
        {
                return 2*pi*m_R;
        }
        
        // 设置半径的成员方法 成员函数可以修改成员属性的
        void setR(int r)
        {
                m_R = r;
        }
        
        // 半径 成员属性
        int m_R;
};

void test01()
{
        //通过类 来创建一个圆
        Circle c1; // 圆 (对象)

        //c1.m_R = 10; // 给这个对象来进行半径的赋值

        //通过成员函数 间接给圆设置半径
        c1.setR(10);

        //输出c1的周长
        cout << "c1的周长：" << c1.calculateZC() << endl;
}

int main()
{
        test01();
        return 0;
}

设计类 抽象类

class 类名{

public 公共权限

设置 成员属性

设置 成员函数

}

使用类 创建对象 实例化对象

类名 对象名

通过对象 来设置属性 调用成员函数

 

类和对象的关系？？？

类是对对象的抽象，对象是对类的实例

 

2. 内联函数

内联函数的引出——宏函数的缺陷

缺陷1：要注意加括号

#define MyAdd(x,y) x+y

void test01()
{
    int ret = MyAdd(10,20)*20;        // 预期结果 600 （10+20）*20    
    cout << "ret= " << ret << endl;   // 实际结果 410 10+20*20
}

缺陷2：比较后自加

#define MyCompare(a,b) ((a)<(b)) ? (a):(b)

void test02()
{
    int a = 10;
    int b = 20;

    int ret = MyCompare(a,b);           // ((a)<(b)) ? (a):(b)
    cout << "ret= " << ret << endl;     // 没有错

    int ret1 = MyCompare(++a,b);        // 预期结果 11
    cout << "ret1= " << ret1 << endl;   // 实际结果 12 ((++a)<(b)) ? (++a):(b)
}

缺陷3：宏函数也没有作用域

内联函数本身也是一个真正的函数。

inline void func(int a) (return ++);

内联函数和宏函数差不多，但是内联函数不会出现以上的缺陷了！！！

内联函数注意事项：

inline void func(); // 内联函数声明

void func(); // 如果函数实现时候，没有加inline关键字，那么这个函数依然不算内联函数

类内部额成员函数 默认前面会加inline关键字

 

3. 函数重载

// 函数重载
// C++中 函数的名称可以重复
// 必须在同一个作用域

void func( )
{
    cout << "无参数的func" << endl;
}

void func( int a )
{
    cout << "有参数的func(int a)" << endl;
}

函数的参数个数不同、类型不同、顺序不同 都可以进行函数重载。

当函数重载碰到了默认参数，要注意避免二义性问题。

const也可以作为重载的条件。

 

4. extern C浅析 

// C++中想调用C语言方法

extern "C" void show();  // show方法按照C语言方式做链接

 

5. C++封装和C封装的区别

将属性和行为作为一个整体，来表示生活中具体的事物；

有访问权限；

class和struct唯一的区别：默认权限不同

#include 
#include 
using namespace std;

struct Person
{
        char mName[64];
       
        int mAge;

        void PersonEat()
        {
                cout << mName << "吃人饭" << endl;
        }
};

struct Dog
{
        char mName[64];

        int mAge;

        void DogEat()
        {
                cout << mName << "吃狗粮" << endl;
        }
};

// C++中的封装 严格类型转换检测 让属性和行为绑定在一起
// 属性和行为作为一个整体来表示生活中的事物
// 控制权限 pubilc 公有权限 protected 保护权限 privete 私有权限
void test01()
{
        Person p1;
        strcpy(p1.mName,"老王");
        p1.PersonEat();
}

// struct 和 class 是一个意思，唯一的不同是默认权限
// struct 是 public，但是 class 是 private
// 所谓的私有权限 就是私有成员（属性、函数） 在类的内部可以访问，类外部不可以访问
// 公有权限 在类的内部和外部都可以访问

class Animal
{
private:
        void eat()
        {
                mAge = 100;
        }

        int mAge;
public:
        int mHeight;
protected: //保护权限，类内部可以访问，外部不可以访问，当前类的子类可以访问
        int mWeigt;
};

void test02()
{
        Animal an;
        // an.eat();
        // an.mAge; // 私有不可以访问

        an.mHeight = 100; // 公有权限可以在类的外部访问
}

int main()
{
        test01();
        return 0;
}