Linux / C / shell / python
C++：对象数组、对象动态申请和释放、类的定义和实现分开、this指针、常成员函数、时钟
一、对象数组的定义和初始化
1. 对象数组的创建方法：
//常量都是无名对象1）类类型 数组名[元素个数];2）类类型 数组名[元素个数] = { 数组的初始化列表... };
2. 说明：1）在没有初始化列表的数组中，所有对象默认调用无参的构造函数。2）对于有初始化列表的数组中，可以用构造函数来生成"类类型"的无名对象来初始化数组内的元素。/** 代码演示 **/
#include &iostream&
class Student {
Student(const string & n = "无名", double s = 0.0)
: name(n), score(s) {
void printInfo() {
cout && "我叫" && name && "，我的成绩" && score &&
int main(void) {
//int arr2[3] = {1, 2};
Student arr2[3] = {Student(), Student("赵云", 97)};
for(int i = 0; i & 3; i++) {
arr2[i].printInfo();
cout && "------------" &&
//int arr[10]; //等同如下
Student arr[10];
for(int i = 0; i & 10; i++) {
arr[i].printInfo();
二、对象的动态申请和释放
1. new/delete 来申请和释放单个对象1）new 类类型2）new 类类型(实参表)
2. new[]/delete[] 来动态创建对象数组new 类名[元素个数];说明：new[] 只能以无参形势调用相应的构造函数
3. new 和 malloc 区别malloc之分配内存空间，new 做了两件事：1）用malloc分配内存空间 //malloc是由系统来提供和分配的2）调用构造函数来初始化这个空间所存放的对象/** 代码演示 **/
#include &iostream&
class Student {
Student(const string & n = "无名", double s = 0.0)
: name(n), score(s) {
void printInfo() {
cout && "我叫" && name && "，我的成绩" && score &&
void setNameScore(const string & n, const double s) {
if(s & 0 || s & 100.0) //数据校验，保证数据安全
int main(void) {
Student * ps = new S
ps-&printInfo();
ps = new Student("张飞", 60);
ps-&printInfo();
//以下创建动态对象数组
ps = new Student[3]; //创建的时候不能初始化,C11可初始化(不常用)
ps[0] = Student("张飞", 60);
ps[1].setNameScore("关羽", 70);
ps[2] = Student("刘备", 80);
for(int i = 0; i & 3; i++) {
ps[i].printInfo();
ps = NULL;
【练习：实现一个电子始终类 Clock类】
#include &time.h&
time_t time(time_t *t);
//time_t (unsigned long long) 返回
00:00:00 至今的秒数
将time_t转换为年月日十分秒的方法：time_t tt = time(NULL);struct tm *p = localtime( &tt ); //&tt是地址p-&tm_ //小时，整型值p-&tm_ //分钟，整型值p-&tm_ //秒，整型值
time_t tt = time(0); struct tm *time = localtime(&tt);
printf("%4d-%02d-%02d\n", time-&tm_year+1900,time-&tm_mon+1,time-&tm_mday); //打印年月日class Clock {public:void run() {//循环while(1) {//打印当前的时间 00:00:00sleep(1);//将second成员加1秒}}成员：小时hour、分钟minute、秒second}int main(void) {Clock c( time(NULL) );
//time(NULL) 设置时钟的起始时间c.run(); //让时间运行return 0;}/** 代码演示 - teacher **/
#include &stdio.h&
class Clock {
Clock(time_t tt = 0) { // 00:00:00
struct tm *p = localtime(&tt);
hour = p-&tm_
minute = p-&tm_
second = p-&tm_
void run() {
while(1) {
showTime();//显示时间
tick(); //滴答，时间+1s
void tick() {
//时间校正算法:
minute += second/60; //0 or 1
second %= 60;//second不超过60
hour += minute/60;//0 or 1
minute %= 60;//minute不超过60
hour %= 24;//hour不超过24
void showTime() {
printf("\r%02d : %02d : %02d", hour, minute, second);
fflush(stdout);
int main(void) {
Clock c(time(NULL));
三、类的定义和实现分开
1. 成员函数的实现有两种方式：1）类内声明，类内实现2）类内声明，类外实现
/** 代码演示如下 **/类内声明的方法不变；类外实现的时候，"函数名前要加作用域的限定"。如果函数形参表带有缺省实参，只能保留一个地方带有缺省实参，建议：将"缺省实参写在声明的地方"。3）实现和声明分开：时钟例子："多文件编程"clock.cpp //类的实现
#include "clock.h"clock.h
//类的声明、头文件声明、条件编译main.cpp （主函数） // #include "clock.h"
$: g++ clock.cpp main.cpp -o myclock
$: myclock
16 : 38 : 43/** 三、1. 2）类内声明，类外实现 **/
#include &iostream&
#include &time.h&
#include &stdio.h&
class Clock {
Clock(time_t tt = 0);
void run();
void showTime();
void tick();
Clock::Clock(time_t tt) { //类外声明不能加默认实参
struct tm *p = localtime(&tt);
hour = p-&tm_
minute = p-&tm_
second = p-&tm_
void Clock::run() { //在函数名前加作用域限定符
while(1) {
showTime();
void Clock::tick() {
minute += second/60;
second %= 60;
hour += minute/60;
minute %= 60;
hour %= 24;
void Clock::showTime() {
printf("\r%02d : %02d : %02d", hour, minute, second);
fflush(stdout);
int main(void) {
Clock c(time(NULL));
四、this 指针
1. 在类内总有一个已定义的指针 this ，在成员函数调用时，this 指向调用这个函数的对象。
2. 作用：1）用来区分一个对象内"标识符"的作用域；2）成员函数可以用 this 返回调用对象的地址；3）成员函数可以用 this 返回调用对象自身的引用；4）成员函数可以用 this 指针来销毁自身；
3. 说明：1）this 只能在成员函数内调用；2）在C++编译器中只有一个 this 哪个对象在调用成员函数时，这个 this 就指向那个对象；3）this 不占用对象的存储空间。/** 代码演示 **/
#include &iostream&
class Teacher {
Teacher(string name, int a) {
this-&name = //this不占用对象的空间,1）区分标识符作用域
cout && "Teacher() this =" && this &&
void printInfo() {
cout && "printInfo() this =" && this &&
cout && "我叫" && name && "，今年" && age && "。\n";
Teacher * getMySelf() { } //2）返回调用对象地址
Teacher & getSelf() { return * } //3）返回调用对象的引用
void freeSelf() {
cout && "delete " && this &&
} //4）销毁自身
//封装了指针，4个字节
int main(void) {
Teacher t1("老魏", 40);
t1.printInfo();
cout && "&t1 = " && &t1 &&
cout && "t1.getMySelf() = " && t1.getMySelf() &&
Teacher & rt1 = t1.getSelf();
rt1.printInfo();
//4）以下示意对象销毁自身
Teacher *p = new Teacher("孔明", 40);
cout && "p = " && p &&
p-&freeSelf();
cout && "---------------------" &&
Teacher t2("老王", 30);
t2.printInfo();
cout && "&t2 = " && &t2 &&
cout && "sizeof(t1)" && sizeof(t1) &&//8
五、常成员函数
1. 常成员函数的语法形式：类型 成员函数名 (形参表) [ const ] [ throw 列表 ] { ... }具有 const 修饰的成员函数叫"常成员函数"。
2. 作用：1）一个有常属性的对象只能调用常成员函数；2）一个常成员函数不能修改对象内的成员，否则报错。"只读"
3. 说明：1）具有常属性的对象只能调用常成员函数；2）没有常属性的对象可以调用常成员函数，也能够调用普通成员函数，但会优先调用普通成员函数；3）有常属性的成员函数与普通成员函数可以构成重载；4）常成员函数不能修改对象自身的成员；5）常成员函数不能返回非 const 属性的成员的引用（包括指针）；/** 代码演示 **/
#include &iostream&
class Person {
Person(const string & n): name(n) {}
void printInfo() { //重载，优先普通成员函数
cout && "我是普通的" && name &&
void printInfo() const {
cout && "const我叫" && name &&
const string & getName() const { }
void setName(const string & n) {
int main(void) {
const Person p("小张");
p.printInfo();
p.setName("张飞"); //出错，因为p为常对象
Person p2("小李");
p2.setName("李某某");
p2.printInfo();
const string & alias = p.getName();
alias = "李四";
p2.printInfo();
六、 mutable 关键字(变化的)在具有常属性的成员函数中，不能修改成员对象的值，但有 mutable 修饰的成员对象除外。/** 代码演示 **/
class Person {
Person(const string & n): name(n), count(0) {}
//不受成员函数const限定符的限制
int main(void) {
const Person p("小张");
p.printInfo();
const string & alias = p.getName();
alias = "小李"; //报错！！！
p.printInfo();
作业：写过的时钟类，改为定时器，进行定时后，在时间到来时，做相应的事儿。/** 【时钟案例】增加代码 **/
void Clock::alarmRun(short h, short m, short s) {
while(1) {
showTime();
if(hour == h && minute == m && second == s) {
doSomething();
void Clock::doSomething() {
cout && "时间到了，起床！\n";
#include "clock.h"
int main(void) {
Clock c(time(NULL));
c.alarmRun(10, 31, 0);
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！C++ 对象数组 对象指针 动态生成对象 作业_百度文库
您的浏览器Javascript被禁用，需开启后体验完整功能，
赠送免券下载特权
10W篇文档免费专享
部分付费文档8折起
每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
C++ 对象数组 对象指针 动态生成对象 作业
阅读已结束，下载本文需要
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩4页未读，
定制HR最喜欢的简历
你可能喜欢Learn & Innovate
C++对象指针数组与堆中对象数组
#include &IOSTREAM&
/*堆中对象数组、对象指针数组*/
void set(int x){i = x + 6;}
int get(){return i*i;};
void main()
const int n = 1000;
stu * p = new stu[n];//在堆中定义了一个对象数组，并将其首地址传送给对象指针p.
stu * p0 =
for (i=0; i&n; i++)
p-&set(i);
cout&&"p["&&i&&"]:"&&p-&get()&&
delete [] p0;//删除堆中对象数组;(注：此处p0不可换为p,因为p的值在for循环中已被改变，不再是数组的首地址了。)
const int m = 1000;
stu * p1[m]; //p1成了指针数组的数组名，是个指针常量
for (i=0; i&m; i++)
p1[i] =//数组p1中，每个元素都是个对象指针，故可以直接被new stu赋值。
p1 = p1+i;//错误，p1是个数组名，是个指针常量
p1[i]-&set(i+1);
cout&&"p1["&&i&&"]:"&&p1[i]-&get()&&
delete p1[i];
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！如何建立自定义类的对象数组?
[问题点数：50分，结帖人LJN]
本版专家分：690
CSDN今日推荐
本版专家分：125
本版专家分：290
本版专家分：690
本版专家分：85
本版专家分：115
本版专家分：290
本版专家分：690
本版专家分：7825
2010年4月 授予百度VIP勋章
匿名用户不能发表回复！|
CSDN今日推荐在C加加中如何把对象存入对象数组中_百度知道
在C加加中如何把对象存入对象数组中
我有更好的答案
试一下以下代码，a到c，a是要找重复数据的List，里面都是a的重复数据，只出现一次的已经过滤掉了。如果c里面的数据要求不重复，把ArrayList换成HashSet就行了。
List a = new ArrayList();
a.add(&123&);
a.add(&123&);
a.add(&123&);
a.add(&123&);
a.add(&456&);
a.add(&789&);
a.add(&123&);
Set b = new HashSet();
ArrayList c = new ArrayList();
for (int i = 0; i & a.size(); i++) {
Object x = a.get(i);
if (b.contains(x)) {
专注培养IT技术人才
主营：PHP培训，JAVA培训，HTML5培训，UI培训，Linux培训，Python培训
为您推荐：
其他类似问题
对象数组的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。}