#include <iostream>
using namespace std;
class Dog
{
public:
char name[64];
//面向对象,方法在类的内部,因为对象的本质是class类型的变量,方法在类内部时,对象调用自身内部的方法就可以完成需求,即以对象为中心的编程思想
void eat(char *food)
{
cout << name << " eat " << food << endl;
}
};
//面向过程,方法(即函数)在类的外面,方法不属于类
void eat(class Dog &dog, const char *food)
{
cout << dog.name << " eat " << food << endl;
}
//圆的周长
double getCircleGirth(double r)
{
return 2 * 3.14 * r;
}
//圆的面积
double getCircleArea(double r)
{
return 3.14 * r * r;
}
//命名规范
//1.类的名字首字母大写
//2.方法的名字首个单词全小写,其余单词首字母大写
//面向对象
class Circle
{
public:
void setR(double r)
{
my_r = r;
}
double getCircleGirth()
{
return 2 * 3.14 * my_r;//my_r为类内部私有成员变量,类内部的方法可以直接调用,不会产生歧义
}
double getCircleArea()
{
return 3.14 * my_r * my_r;
}
private:
//circle类的私有成员,即圆的半径
double my_r;
//下面一段代码的写法是错误的,首先初始化类的对象时,变量与变量是同级且互不干扰的
//my_r初始化时是没有值的,也就是是乱码,当my_girth初始化时是2 * 3.14 * my_r(乱码),当调用对象的方法时,虽然my_r被重新赋值了,但是my_girth与my_r此时是同级且互不相关的,所以这种写法是错误的
//float my_girth = 2 * 3.14 * my_r;
};
int main()
{
Dog dog;
strcpy_s(dog.name, strlen("dahuang") + 1, "dahuang");
//面向过程,以方法(函数)为中心
eat(dog, "beaf");//"beaf"为字符串常量,类型为const char *,所以在声明函数时,函数第二个参数因为const char *类型,声明char *类型会报错
//面向对象,以对象(变量)为中心
char food[64] = "apple";//这种定义,food为局部变量,不在常量区了
//const char *food = "apple"
dog.eat(food);
double r = 10;
double girth;
double area;
girth = getCircleGirth(r);
area = getCircleArea(r);
cout << "circle girth=" << girth << endl;
cout << "circle area=" << area << endl;
Circle circle;
circle.setR(10);
cout << "circle girth=" << circle.getCircleGirth() << endl;
cout << "circle area=" << circle.getCircleArea() << endl;
return 0;
}
using namespace std;
class Dog
{
public:
char name[64];
//面向对象,方法在类的内部,因为对象的本质是class类型的变量,方法在类内部时,对象调用自身内部的方法就可以完成需求,即以对象为中心的编程思想
void eat(char *food)
{
cout << name << " eat " << food << endl;
}
};
//面向过程,方法(即函数)在类的外面,方法不属于类
void eat(class Dog &dog, const char *food)
{
cout << dog.name << " eat " << food << endl;
}
//圆的周长
double getCircleGirth(double r)
{
return 2 * 3.14 * r;
}
//圆的面积
double getCircleArea(double r)
{
return 3.14 * r * r;
}
//命名规范
//1.类的名字首字母大写
//2.方法的名字首个单词全小写,其余单词首字母大写
//面向对象
class Circle
{
public:
void setR(double r)
{
my_r = r;
}
double getCircleGirth()
{
return 2 * 3.14 * my_r;//my_r为类内部私有成员变量,类内部的方法可以直接调用,不会产生歧义
}
double getCircleArea()
{
return 3.14 * my_r * my_r;
}
private:
//circle类的私有成员,即圆的半径
double my_r;
//下面一段代码的写法是错误的,首先初始化类的对象时,变量与变量是同级且互不干扰的
//my_r初始化时是没有值的,也就是是乱码,当my_girth初始化时是2 * 3.14 * my_r(乱码),当调用对象的方法时,虽然my_r被重新赋值了,但是my_girth与my_r此时是同级且互不相关的,所以这种写法是错误的
//float my_girth = 2 * 3.14 * my_r;
};
int main()
{
Dog dog;
strcpy_s(dog.name, strlen("dahuang") + 1, "dahuang");
//面向过程,以方法(函数)为中心
eat(dog, "beaf");//"beaf"为字符串常量,类型为const char *,所以在声明函数时,函数第二个参数因为const char *类型,声明char *类型会报错
//面向对象,以对象(变量)为中心
char food[64] = "apple";//这种定义,food为局部变量,不在常量区了
//const char *food = "apple"
dog.eat(food);
double r = 10;
double girth;
double area;
girth = getCircleGirth(r);
area = getCircleArea(r);
cout << "circle girth=" << girth << endl;
cout << "circle area=" << area << endl;
Circle circle;
circle.setR(10);
cout << "circle girth=" << circle.getCircleGirth() << endl;
cout << "circle area=" << circle.getCircleArea() << endl;
return 0;
}