C++中关于面向对象的问题
添加一个类后会自动生成两个文件,如:People.cpp,People.h
People.cpp
#include "People.h"
#include<stdio.h>
People::People(void)
{
}
People::~People(void)
{
}
void People::sayHello()
{
printf("Hello CPP");
}
People.h
#pragma once
class People
{
public:
void sayHello();
People(void);
~People(void);
};
main.cpp
#include<iostream>
#include"People.h"
/*class People{
public :
void sayHello()
{
printf("Hello CPP");
}
};
*/
int main(int args,char * argv[])
{
People * p =new People;
p->sayHello();
return 0;
}
C++命名空间
已命名空间区别同名的类
People.cpp
#include "People.h"
#include<stdio.h>
namespace First{
People::People(void)
{
}
People::~People(void)
{
}
void People::sayHello()
{
printf("Hello CPP");
}
}
People.h
#pragma once
namespace First{
class People
{
public:
void sayHello();
People(void);
~People(void);
};
}
main.cpp
#include<iostream>
#include"People.h"
using namespace First;//引用First命名空间
int main(int args,char * argv[])
{
People * p =new People;
p->sayHello();
delete p;
return 0;
}
继承
Man.h
#include"People.h"
#pragma once
class Man:public People
{
public:
Man(void);
~Man(void);
};
Man.cpp
#include "Man.h"
Man::Man(void)
{
}
Man::~Man(void)
{
}
People.h
#pragma once
class People
{
private:
int age;
int sex;
public:
void sayHello();
int getAge();
int getSex();
People();
People(int age,int sex);
~People(void);
};
People.cpp
#include "People.h"
#include<stdio.h>
//namespace First{
People::People()
{
}
People::People(int age,int sex)
{
this->age=age;
this->sex=sex;
}
People::~People(void)
{
}
void People::sayHello()
{
printf("Hello CPP");
}
int People::getAge()
{
return this->age;
}
int People::getSex()
{
return this->sex;
}
main.cpp
#include<iostream>
#include"People.h"
#include"Man.h"
int main(int args,char * argv[])
{
Man * man=new Man;
man->sayHello();
People * p =new People;
p->sayHello();
return 0;
}
构造与析构
#include<iostream>
#include"People.h"
#include"Man.h"
//using namespace First;
/*class People{
public :
void sayHello()
{
printf("Hello CPP");
}
};
*/
class Object{
public:
Object()//构1造ì函ˉ数簓没?有瓺返う?回?值μ
{
printf("create object");
};
~Object()
{
printf("delete object");
};
};
void runObject()
{
Object obj;//如果给这段代码加上大括号,会先执行大括号里面的构造和析构后再往下执行,即是一个代码块执行结束就执行析构,就是在大括号结束后执行析构函数
}
int main(int args,char * argv[])
{
//Man * man=new Man;
//man->sayHello();
//People * p =new People;
//p->sayHello();
//delete p;
//Object *obj = new Object;
//delete obj;
runObject();//此时会执行构造和析构
//return 0;
}
调用父类的构造方法
Man::Man(int age):People(age,1)//调用父类的构造方法
{
}
int main(int args,char * argv[])
{
Man * m = new Man(20);
int a = m->getAge();//可以调用父类的构造方法
return 0;
}
虚函数
People *p =new Man(20);
p->sayHello();//执行的是People中sayHello的方法,不是Man中的方法,必须将People父类里的方法定义为虚函数,才可以调用Man类中的方法,否则只可以调用父类中的方法,是在定义出加virtual(即.h文件中),并且在子类中定义该方法时也要定义virtual
纯虚数函
int main(int args,char * argv[])
{
People *p =new Man(20);
p->sayHello();//执行的是People中sayHello的方法,不是Man中的方法,必须将People父类里的方法定义为虚函数,才可以调用Man类中的方法,否则只可以调用父类中的方法,是在定义出加virtual(即.h文件中),并且在子类中定义该方法时也要定义virtual
p->eat();//People可以调用在Man类中实现的纯虚方法
}
#pragma once
class People
{
private:
int age;
int sex;
public:
virtual void sayHello();
virtual void eat()=0;//纯虚函数,该类中不实现
int getAge();
int getSex();
People();
People(int age,int sex);
~People(void);
};
#include"People.h"
#include<stdio.h>
#pragma once
class Man:public People
{
public:
Man(void);
Man(int age);
virtual void sayHello();
void eat()
{
printf("eat \n");
};
~Man(void);
};
一个类中包含纯虚函数就为抽象类,即使包含其他类的函数,纯虚类就是该类中的所有函数都是纯虚函数,相当于Java语言中的接口。C++语言中可以多重继承
函数重载
class Hello
{
public :
void sayHello()
{
printf("say Hello");
};
void sayHello(char * name)
{
printf("%s say Hello ",name);
};
};
int main(int args,char * argv[])
{
Hello * h = new Hello();
string s = "zhangsan";
h->sayHello((char*)s.c_str());
}
运算符重载
引用:节省资源
class Point{
private:
int x,y;
public:
Point(int x,int y)//构造函数无需加void 也没有返回值
{
this->x= x;
this->y = y;
};
int getX()
{
return this->x;
};
int getY()
{
return this->y;
};
void add(int x,int y)
{
this->x = x+1;
this->y = y+1;
printf("%d\n",this->x);
printf("%d\n",this->y);
};
void add(Point & p)
{
add(p.x,p.y);
};
};
int main(int args,char * argv[])
{
Point p(1,1);
Point p1(2,3);
p.add(p1);
}
友元类:
子类无法访问父类的私有成员,高耦合,不常用
class A
{
friend class B;
private:
int num;
public:
A()
{
num=10;
}
};
class B:public A
{
public:
B()
{
printf("%d",num);
}
};
标准容器库基本用法
int main(int args,char * argv[])
{
std::list<std::string> l;
l.push_back("hello");
l.push_back("CPP");
for(std::list<std::string>::iterator it = l.begin();it!=l.end();it++)
{
cout<<*it<<"\n";
}
std::map<std::string,std::string> m;
m.insert(pair<string,string>("hello","cpp"));
m.insert(pair<string,string>("name","zhangsan"));
cout<<m.at("hello")<<"\n";
m["name"]="zhangsan";//重载了[]运算符
}