C++小白开始努力学习编程

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";//重载了[]运算符

}