Day28.C++02
001.作业案例_设计圆类求周长
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
const double pi = 3.14;
//1.设计一个类,求圆的周长
//周长公式 2 * pi * r
class Circle//class 代表声明一个类,后面紧跟的是类的名称
{
public://公共权限
//求圆的周长
//在类里面写函数 成员函数
double caculateZC()
{
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.caculateZC() << endl;
}
int main(void)
{
test01();
system("pause");
return EXIT_SUCCESS;
}
002.作业案例_设计学生类
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
/*
2.设计一个学生类,属性有姓名和学号,可以给姓名和学号赋值,可以显示学生的姓名和学号
*/
class Student
{
public://公共权限
string m_Name;
int m_Id = NULL;
void setName(string name)
{
m_Name = name;
}
void setId(int id)
{
m_Id = id;
}
void showInfo()
{
cout << "姓名:" << m_Name << " " << "学号为:" << m_Id << endl;
}
};
void test01()
{
//创建一个学生,实例化——通过类来创建对象的过程
Student st;
st.setName("刘备");
st.setId(2020666);
st.showInfo();
}
int main(void)
{
test01();
system("pause");
return EXIT_SUCCESS;
}
003.内联函数的引出-宏函数的缺陷
简单总结:
//1.内联函数注意事项
inline void func();//内联函数声明
inline void func() {};//如果函数实现的时候,没有加inline关键字,那么这个函数依然不算内联函数
//类内部的成员函数 默认前面会加inline关键字
/*
内联编译会有一些限制,以下情况编译器可能考虑不会将函数进行内敛编译:
1.不能存在任何形式的循环语句
2.不能存在过多的条件判断语句
3.函数体不能过于庞大
4.不能对函数进行取址操作
*/
//内敛仅仅只是给编译器的一个建议,编译器不一定接受这种建议。
//如果你没有将函数声明为内联函数,那么编译器也可能将此函数做内联编译。
//一个好的编译器将会内联小的简单的函数。
代码:
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//定义一个加法
#define myAdd(x,y) x+y
//缺陷1
void test01()
{
int ret = myAdd(10, 20) * 20;//预期结果600,实际结果410 解决方法:加小括号 ((x) + (y))
cout << "ret = " << ret << endl;
}
#define myCompare(a,b) ((a) < (b)) ? (a) : (b)
//缺陷2
void test02()
{
int a = 10;
int b = 20;
int ret = myCompare(++a, b);//预期结果:11 实际结果:12
cout << "ret = " << ret << endl;
}
//缺陷3:宏函数也没有作用域
//内联函数
inline void myCompare_1(int a, int b)
{
int ret = a < b ? a : b;
cout << "ret = " << ret << endl;
}
//1.内联函数注意事项
inline void func();//内联函数声明
inline void func() {};//如果函数实现的时候,没有加inline关键字,那么这个函数依然不算内联函数
//类内部的成员函数 默认前面会加inline关键字
/*
内联编译会有一些限制,以下情况编译器可能考虑不会将函数进行内敛编译:
1.不能存在任何形式的循环语句
2.不能存在过多的条件判断语句
3.函数体不能过于庞大
4.不能对函数进行取址操作
*/
//内敛仅仅只是给编译器的一个建议,编译器不一定接受这种建议。
//如果你没有将函数声明为内联函数,那么编译器也可能将此函数做内联编译。
//一个好的编译器将会内联小的简单的函数。
void test03()
{
int a = 10;
int b = 20;
myCompare_1(++a, b);
}
int main(void)
{
//test01();
//test02();
test03();
system("pause");
return EXIT_SUCCESS;
}
004.函数默认参数以及占位参数
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//函数的默认参数 参数后面 = ···
//函数参数的注意事项,如果有一个位置有了默认参数,那么从这个位置开始,从左往右都必须有默认参数
//传入参数时,如果有传入参数,就用传入的参数;如果没有传入的参数,就用默认值
//如果函数声明里面有了 默认参数,那么函数实现的时候必须没有(否则会报重定义)
//函数声明和实现里,只能有一个里面有默认参数,不要同时都出现默认参数
void myFunc(int a = 10, int b = 10);
void myFunc(int a, int b) {}
void func(int a,int b = 10,int c = 1)
{
cout << "a + b + c = " << a + b + c << endl;
}
void test01()
{
//func();
func(1,2);
}
//函数,占位参数
//如果有了占位参数,函数调用的时候必须要提供这个参数,但是用不到
//占位参数,没啥大用,只有后面重载 ++符号才有一点点用
//占位参数 可以有默认值
void func_2(int a,int = 1)
{
}
void test02()
{
func_2(10, 1);
}
//C语言中没有默认参数和占位参数
int main(void)
{
test01();
system("pause");
return EXIT_SUCCESS;
}
005.函数重载的基本语法
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//函数重载
//C++中 函数名可以重复
//必须在同一个作用域,函数名称相同
//函数的参数个数不同,或者类型不同,或者顺序不同
void func()
{
cout << "无参数的func()" << endl;
}
void func(int a)
{
cout << "有参数的func(int a)" << endl;
}
//返回值可以作为函数重载的依据吗?? 不可以!
void test01()
{
func(1);
}
//当函数重载 碰到了 默认参数的时候,要注意避免二义性的问题
void func02(int a, int b = 10)
{
}
void func02(int a)
{
}
void test02()
{
//func02(10);
}
//引用的重载版本
void func03(int& a)//引用必须要引合法的内存空间
{
cout << "int& a" << endl;
}
void func03(const int& a)//const 也是可以作为重载的条件
{
cout << "const int& a" << endl;
}
void test03()
{
int a = 20;
func03(a);
func03(10);
}
int main(void)
{
test01();
system("pause");
return EXIT_SUCCESS;
}
006.extern C浅析
extern C浅析.cpp
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include"test.h"
//C++中想调用C语言方法
//extern "C" void show();//show方法按照C语言方式做连接
int main(void)
{
show();//在C++中,函数是可以发生重载的,编译器会把这个函数名称偷偷改变 _showv()
system("pause");
return EXIT_SUCCESS;
}
test.h
#pragma once
#ifdef __cplusplus//两个下划线
extern "C" {
#endif
#include<stdio.h>
void show();
#ifdef __cplusplus//两个下划线
}
#endif
test.c
#include"test.h"
void show()
{
printf("hello world!\n");
}
007.C语言下封装和C++封装的区别
C语言下的封装:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Person
{
char mName[64];
int mAge;
};
struct Dog
{
char mName[64];
int mAge;
};
void personEat(struct Person* p)
{
printf("%s吃中餐\n", p->mName);
}
void dogEat(struct Dog* d)
{
printf("%s吃狗粮\n", d->mName);
}
void test01()
{
struct Person p1;
strcpy(p1.mName, "老王");
struct Dog d1;
strcpy(d1.mName, "旺财");
dogEat(&p1);
dogEat(&d1);
}
//C语言封装 属性和行为分开处理了;再加上类型检测不够
//所以就会出现“老王吃狗粮”的结果
int main(void)
{
test01();
system("pause");
return EXIT_SUCCESS;
}
C++语言的封装:
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
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++中的封装 严格类型转换检测,让属性和行为绑定到一起
//属性和行为作为一个整体来表示生活中的事物
//控制权限:public 公共权限 protected 保护权限 private 私有权限
void test01()
{
Person p1;
strcpy(p1.mName, "老王");
p1.personEat();
//p1.dogEat();
}
//struct和class是一个意思,唯一的不同就是默认权限;struct是public,但是class是private
class Animal
{
private:
//如果不声明权限,默认权限是private
void animalEat() {}
void setAge(int age)
{
mAge = age;
}
int mAge;
public:
int mHeight;
protected://保护权限,类内部可以访问,(当前类的子类可以访问),类外部不可以访问
int mWeight;
void setWeight(int weight)
{
mWeight = weight;
}
};
//所谓私有权限,就是私有成员(属性、函数)在类内部可以访问,类外部不可以访问
//公共权限,在类内部和类外部都可以访问
void test02()
{
Animal an;
//an.animalEat();//私有权限
an.mHeight = 100;//共有权限在类外部可以访问到
//an.mWeight = 100;//保护权限
}
/*
public 类内,类外 都可以访问
protected 类内可以访问 类外不可以访问(子类可以访问)
private 类内可以访问 类外不可以访问
*/
int main(void)
{
test01();
system("pause");
return EXIT_SUCCESS;
}
008.建议将成员变量设置为private
建议将成员变量设置为私有,对外提供公共的set和get方法来操作变量。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
void setName(string name)
{
m_Name = name;
}
string getName()
{
return m_Name;
}
void setAge(int age)
{
if (age < 0 || age>130)
{
cout << "你个老妖精" << endl;
return;
}
m_Age = age;
}
int getAge()
{
return m_Age;
}
void setLover(string lover)
{
m_Lover = lover;
}
private:
string m_Name;//姓名,读写
int m_Age = 1;//年龄,读写
string m_Lover;//爱的人,只写
};
void test01()
{
Person p1;
p1.setAge(18);
p1.setName("徐哥哥");
p1.setLover("小马");
cout << p1.getName() << "的年龄为:" << p1.getAge() << "岁" << endl;
}
int main(void)
{
test01();
system("pause");
return EXIT_SUCCESS;
}