您的位置:首页 > 编程语言 > C语言/C++

c++学习

2015-06-13 23:50 357 查看
#include<iostream>

int main()
{
std::cout<<"test \n";
int sjk;
std::cin>>sjk;
std::cout<<sjk;
return 0;
}


#include <iostream>
//using std::cout;
//using std::endl;

using namespace std;

int main()
{
cout<<"test \n";
cout<<endl;

return 0;
}


命名空间冲突问题

#include <iostream>
//using namespace std;

namespace a{
int a=1;
}

namespace b{
int a=2;
}

int main()
{
//int a=3;
using namespace a;
using namespace b;
std::cout<<a<<"|"<<a::a<<"|"<<b::a<<std::endl;

return 0;
}


函数应用

#include <iostream>
using namespace std;

int sum(int a, int b)
{
return a+b;
}

int main()
{
int a, b;

cin>>a;
cin>>b;

cout<<"a+b="<<sum(a,b);

return 0;
}


函数的声明与定义

#include <iostream>
using namespace std;

//函数声明
//int sum(int a, int b);
int sum(int, int); //参数名可以省略

int main()
{
int a, b;

cin>>a;
cin>>b;

cout<<"a+b="<<sum(a,b);

return 0;
}

//函数定义
int sum(int a, int b)
{
return a+b;
}


#include <iostream>
using namespace std;

void a();
void b();

void a()
{
cout<<"a \n";
b();
}

void b()
{
cout<<"b \n";
a();
}

int main()
{
a();

return 0;
}


变量范围

#include <iostream>
using namespace std;

int x,y;//全局变量对任何函数都有效

void change()
{
x=100;
}

int main()
{
change();
cout<<x;

return 0;
}


款字符型

#include <iostream>
#include <locale>

using namespace std;

int main()
{

setlocale(LC_ALL, "chs");
wchar_t wc[] = L"中";
wcout<<wc;

return 0;
}


#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
double a=1.32545488787778575; // 有效 6~7位
//cout<<setprecision(15)<<a;

const int b =1;

//枚举用字母代替数字
//enum num{zero, one, two, three}; //默认从0开始计算
enum num{zero=100, one, two=300, three}; //默认从0开始计算

cout<<one;

num n = zeros;
if(n == zero)
{
cout<<"yes";
}else{
cout<<"no";
}

return 0;
}


类的定义与使用:

#include <iostream>

using namespace std;

class man{
public:
void getHeight(){
cout<<height;
}
void getWeight();
void setWeight(int);
public:
int height=0;
int weight;
};

void man::getWeight(){
cout<<weight;
}

void man::setWeight(int n){
weight=n;
}

int main()
{

man p ;
p.setWeight(10);
p.getWeight();

return 0;
}


内联函数:(函数体比较小时比较好)

#include <iostream>

using namespace std;

//效率更高,不必跳来跳去
//编译器不会真正的创建该函数,只是将这个函数的代码拷贝到调用的函数中,提高了效率,增大了程序的体积
inline void print();
void print()
{
cout<<"yes";
}

class man{
public:
void getHeight();
private:
int height;
};

void man::getHeight()
{
cout<<height;
}

int main()
{
//print();
man p;
p.getHeight();

return 0;
}


const函数

class man{
public:
void getHeight();
void setHeight() const { //不想让某个成员函数修改成员变量的值
height = 5;
}
private:
int height;
};


构造函数

#include <iostream>
using namespace std;

class man{
public:
int height;

public:
//注意构造函数没有返回值,不用表明返回值类型
man(int h){
height =h;
}
void getHeight();
void setHeight() { //不想让某个成员函数修改成员变量的值
height = 5;
}
};

int main()
{
man p(55);
cout<<p.height;
return 0;
}


构造函数与析构函数

#include <iostream>
using namespace std;

class man{
public:
int height;

public:
//注意构造函数没有返回值,不用表明返回值类型
man(int h){
height =h;
}

//不能有返回值和参数,有且只有一个
~man()
{

}

void getHeight();
void setHeight() { //不想让某个成员函数修改成员变量的值
height = 5;
}
};

int main()
{
man p(55);
cout<<p.height;
return 0;
}


堆中创建变量和对象

#include <iostream>
using namespace std;

class man{
public:
void getHeight(){
cout<<height;
}
void setHeight()  { //不想让某个成员函数修改成员变量的值
height = 5;
}
private:
int height;
};

int main()
{
//定义时进行初始化
//int *p=0;
int *p=new int;
*p = 1; //变量保存在堆中
cout<<*p;

delete p;
p=0;

man *p1 = new man;
(*p1).setHeight(); // 或 p1.setHeight();
(*p1).getHeight();

delete p1;
p1=0;

return 0;
}


//堆栈内存中变量的释放

#include <iostream>
using namespace std;

class man{
public:
man(){
cout<<"construct \n";
}
~man(){
cout<<"destruct \n";
}
};

int main()
{
//在栈中分配的系统帮你释放
man person ;

//在堆中分配的要手动释放
man *p=new man;
delete p;

return 0;
}


this指针

#include <iostream>
using namespace std;

class man{
public:
man(int sex){
//this指针指向当前对象,由编译器来删除
this->sex=sex; //解决了命名冲突的问题
cout<<this<<"\n";
}
int sex;

};

int main()
{
man p(5);
cout<<&p<<"\n";
cout<<p.sex<<"\n";

return 0;
}


指针的释放

#include <iostream>
using namespace std;

int main()
{
int *p=new int;
*p=3;

cout<<p<<"\n";
delete p;
p=0; //一定要 赋值为 0

int *p1=new int;
cout<<p<<"\n"; //会和p1的地址一样
cout<<p1<<"\n";

*p=33;

cout<<*p1<<"\n";

return 0;
}


引用就是别名,是常量,必须进行初始化

#include <iostream>
using namespace std;

int main()
{

int a=1;
int &b=a; //引用就是别名,地址是相同的,是常量,必须进行初始化

b=2;

cout<<a<<b;
cout<<&a<<"\t"<<&b;
return 0;
}


别名传递

#include <iostream>
using namespace std;

void swap1(int &a, int &b)
{
int c;
c=a;
a=b;
b=c;
}

int main()
{
int a=1,b=2;
swap(a,b);
cout<<a<<"\t"<<b;

return 0;
}


按指(针)传递

#include <iostream>
using namespace std;

void swap(int *a, int *b)
{
int c;
c=*a;
*a=*b;
*b=c;
}

int main()
{
int a=1,b=2;
swap(&a, &b);
cout<<a<<"\t"<<b;

return 0;
}


值传递对象的开销

#include <iostream>
using namespace std;

class man{
public:
man(){cout<<"construct \n";}
man(man&){cout<<"copy \n";}//在栈中创建临时对象的拷贝时调用
~man(){cout<<"destruct \n";}

};

man test(man one)
{
return one;
}

int main()
{

man p;
test(p);

return 0;
}

/**
construct
copy
copy
destruct
destruct
destruct
请按任意键继续. . .
*/


优化1

#include <iostream>
using namespace std;

class man{
public:
man(){cout<<"construct \n";}
man(man&){cout<<"copy \n";}//在栈中创建临时对象的拷贝时调用
~man(){cout<<"destruct \n";}

};

man test(man *one)
{
return *one;//按值返回,会返回对象的副本
}

int main()
{

man p;
test(&p);

return 0;
}


优化2(指针方式传递)

#include <iostream>
using namespace std;

class man{
public:
man(){cout<<"construct \n";}
man(man&){cout<<"copy \n";}//在栈中创建临时对象的拷贝时调用
~man(){cout<<"destruct \n";}

};

man* test(man *one)
{
return one;//按值返回,会返回对象的副本
}

int main()
{

man p;
test(&p);

return 0;
}


按值传递增加const(增加包含机制)

#include <iostream>
using namespace std;

class man{
public:
man(){cout<<"construct \n";}
man(man&){cout<<"copy \n";}//在栈中创建临时对象的拷贝时调用
~man(){cout<<"destruct \n";}
int a;
};

const man* const test(const man *const one)
{
return one;
}

int main()
{

man p;
const man * const p1 = test(&p);
p1++;

return 0;
}


引用于指针

#include <iostream>
using namespace std;

class man{
public:
man(){cout<<"construct \n";}
man(man&){cout<<"copy \n";}//在栈中创建临时对象的拷贝时调用
~man(){cout<<"destruct \n";}
int a;
};

const man& test(const man &one)
{
cout<<&one<<"\n";
return one;
}

int main()
{
int *p=new int;
*p=2;
int *&r=p;//指针的别名
//int &r=*p;//指针的值别名

cout<<*p<<endl;
cout<<*r<<endl;
//cout<<r<<endl;

}


#include <iostream>
using namespace std;

int main()
{
int *&p=new int;

*p=13;

}


引用与指针,返回时的内存释放情况

#include <iostream>
using namespace std;

class a{
public:
a(int x){
this->x=x;
}
a(a &b){this->x=b.x;cout<<"copy";}

public:
int x;

};

a test1()
{
//如果引用是一个临时变量副本,那么这个临时变量的生存期会不少于这个引用的生存期。
a b(10);
return b;  //返回的并非 b对象,而是其副本
}

a& test2()
{
a b(11); //返回局部变量或临时变量的地址
return b;
}

int main()
{
a b = test1();  //right
a *b = &test1();  //如果用指针来接收则不对,副本的内存地址会被立刻释放(但里面的数据可能没有被清楚,所以看起来仍旧是对的)

cout<<b.x<<endl;

}


返回对象副本导致内存泄露

#include <iostream>
using namespace std;

class a{
public:
a(int x){
this->x=x;
}
a(a &b){this->x=b.x;cout<<"copy";}

public:
int x;

};

a test()
{
a *p =new a(10);
return *p;  //返回的对象的副本(分配到栈上),而 p被释放了,会出现内存泄露
//要解决内存泄露就不能反悔对象副本,而是返回指针或别名
}

int main()
{
a &b = test();

/*
这种是错误的,只有栈上的空间采用delete释放
a *p = &b;
delete p;
p=0;
*/

cout<<b.x<<endl;

}


解决上面的问题:

#include <iostream>
using namespace std;

class a{
public:
a(int x){
cout<<"constuct"<<endl;
this->x=x;
}
a(a &b){this->x=b.x;cout<<"copy";}
~a()
{
cout<<"destruct"<<endl;
}

public:
int x;

};

a& test()
{
a *p =new a(10);
cout<<p<<endl;
return *p;
}

int main()
{
a &b = test();
cout<<b.x<<endl;
cout<<&b<<endl;

a *p = &b;
delete p;
p=0;

//注意 此时b别名已经不可以再使用了

}


函数、方法都支持重载,默认值

#include <iostream>
using namespace std;

void test(int a, int b=3)
{
cout<<a<<" "<<b<<endl;
}

void test()
{
cout<<"haha"<<endl;
}

int main()
{
test();
test(5);
test(5,55);

return 0;

}


成员变量赋初值

#include <iostream>
using namespace std;

class man{
public:
//man():age(10),sex(1){}
man(){age=10;sex=1;}

//man(int age=10,int sex=1) {this->age=age; this->sex=sex;}

public:
int age;
int sex;

};

int main()
{
man son;

cout<<son.age<<endl;

return 0;

}


成员变量的初始化

#include <iostream>
using namespace std;

class man{
public:
man():age(10),sex(1){} //初始化

public:
const int age; //@notice
cosnt int sex;

};

int main()
{
man son;

cout<<son.age<<endl;

return 0;

}


#include <iostream>
using namespace std;

class man{
public:
explicit man(int x){age=x;cout<<"consctruct"<<endl;} //关闭类型转换的特性
void setAge(int num){age=num;}
void getAge(){cout<<age<<endl;;}
~man(){cout<<"desctruct"<<endl;}

public:
int age;

};

int main()
{
man son(10);
son.getAge();

son=100; //等价于 son = man(100); 强制类型转换,显式转换

return 0;

}


复制的对象中成员变量有指针

成员拷贝,浅拷贝

#include <iostream>
using namespace std;

class man{
public:
man(){p=new int();*p=110;cout<<"consctruct:"<<age<<endl;}
man(man &a){
p=a.p;
cout<<"copy:"<<age<<endl;
}
~man(){cout<<"desctruct:"<<age<<endl;delete p;p=NULL;}
void setAge(int num){age=num;}
int getAge(){return age;}
int getP(){return *p;}
void setP(int x){*p = x;}

public:
int age;
int *p;

};

int main()
{
man *p1 = new man();
man b = (*p1); //当复制的对象的成员有指针时,指针指向的相同的内存地址,当一个对象析构时,另一个对象的指针也不可以用了

p1->setAge(55);

b.setP(4);
b.setAge(44);

delete p1;
//main函数执行完毕后,会释放 b,再次执行 析构函数释放p,但此时p已经为空,则程序会崩溃
cout<<p1->getP()<<endl;
cout<<p1->getAge()<<endl;

return 0;

}


深层拷贝

#include <iostream>
using namespace std;

class man{
public:
man(){p=new int();*p=110;cout<<"consctruct:"<<age<<endl;}
man(const man &a){ //增加const更好
p = new int();
*p = *(a.p);
cout<<"copy:"<<age<<endl;
}
~man(){cout<<"desctruct:"<<age<<endl;delete p;p=NULL;}

void setAge(int num){age=num;}

int getAge(){return age;}

int getP(){return *p;}

void setP(int x){*p = x;}

public:
int age;
int *p;

};

int main()
{
man *p1 = new man();
man b = (*p1); //当复制的对象的成员有指针时,指针指向的相同的内存地址,当一个对象析构时,另一个对象的指针也不可以用了

p1->setP(22);
cout<<p1->getP()<<endl; // 22
cout<<b.getP()<<endl; // 默认值 110

b.setP(44);
cout<<p1->getP()<<endl;  // 22
cout<<b.getP()<<endl; // 44

delete p1;

cout<<b.getP()<<endl; // 44 删除p1后b不受影响

return 0;

}


运算符重载

#include <iostream>
using namespace std;

class num{
public:
num(){x=1;}
int getX(){
return x;
}

void setX(int x)
{
this->x = x;
}

//运算符重载
void operator++(){
x++;
}

private:
int x;
};

int main()
{
num a;
++a;  // 等价于  a.operator++();

//num j=++a; 这样是错误的相当于 j=a.operator++(), 而其没有返回值

cout<<a.getX()<<endl;

}


解决上面的问题(创建临时对象)

#include <iostream>
using namespace std;

class num{
public:
num(){x=1;}
int getX(){
return x;
}

void setX(int x)
{
this->x = x;
}

//运算符重载
num operator++(){
x++;

num tmp ;
tmp.setX(x);
return tmp;
}

private:
int x;
};

int main()
{
num a;
++a;  // 等价于  a.operator++();

num j=++a;

cout<<j.getX()<<endl;

}


创建对象的3种方式:

#include <iostream>
using namespace std;
class A
{
private:
int n;
public:
A(int m):n(m)
{ }
~A(){}
};
int main()
{
A a(1);  //栈中分配 隐式调用
A b = A(1);  //栈中分配 显式调用
A* c = new A(1);  //堆中分配
  delete c;
return 0;
}


创建无名临时对象

#include <iostream>
using namespace std;

class num{
public:
num(){x=1;}
num(int x){this->x=x;}
int getX(){
return x;
}

void setX(int x)
{
this->x = x;
}

//运算符重载
num operator++(){
x++;

return num(x);
}

private:
int x;
};

int main()
{
num a;
++a;

num j=++a;

cout<<j.getX()<<endl;

}


重载赋值运算符

#include <iostream>
using namespace std;

class num{
public:
num(){x=1;cout<<"construct"<<x<<endl;}

num(int x){this->x=x;cout<<"construct:"<<x<<endl;}

~num(){cout<<"destruct:"<<x<<endl;}

num(num &a){this->x=a.x;cout<<"copy:"<<x<<endl;}

int getX(){
return x;
}

void setX(int x)
{
this->x = x;
}

//运算符重载
num operator+(num &r){

return num(x+r.getX());
}

void operator=(num &r){
cout<<"operator+"<<endl;

}

private:
int x;

};

int main()
{

num a(11),b(22);

b = a;

return 0;
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: