c++ 学习笔记1

c++ 学习笔记

1、c++ 基本数据类型
   ----》整型数据
int  4字节
short int （short） 2字节
long int(long) 4字节;

int j = 5;
short m = 4;
long n = 3L;
   ----》字符数据类型
char 1字节
wchar_t 2字节

char a = ‘a’;
wchar_t b = L'a';

上述几种类型都有无符号类型，用unsigned表示，
如unsigned long k = 5U;

   ----》布尔类型

bool ll = true;
   ----》浮点型
double a = 11.5;
float b = 12.5f;
2、输入输出

int d = 5;
cin >> d;
     cout<<"value is "<<d<<endl;
3、强制类型转换
老式 转换 static_cast

double m = 6.5,n = 7.81;
int k  = static_cast<int>(m)+static_cast<int>(n);//13
int k1 = static_cast<int>(m+n);//14

新式转换
int k2 = (int)m + (int)n;
int k3 = (int)(m+n);
cout<<k2<<k3<<endl;
4、命名空间
namespace

#include <iostream>
using namespace std;

namespace myNs{
int value = 9;
}

void main(){
int value = 10;
cout<<myNs::value<<endl;//9
cout<<value<<endl;//10
}
5、字符数组
---》字符数组以‘\0’结束

定义字符数组  char c1[] = "xx";//自动计算数组长度

#include <iostream>
#include <string>
using namespace std;

void main(){
char str[] = "nihao";
int i =1;
while (str[i]!='\0'){
i++;
}
cout<<"str 长度为"<<i<<endl; //6
}


或用 cout<<std::strlen(str)<<endl; 得到str长度为5

----》输入字符存储并打印
const int MAX = 60;
char str[MAX];
cin.getline(str,MAX,'\n');
cout<<str<<endl;
6、指针
//定义指针
int* a = NULL;//等效于 int* a = 0; NULL 是0的别名 ，但习惯还是用NULL
int m = 88;
a = &m;
cout<<*a<<endl;
//指针运算
int b = *a + 10;
cout<<b<<endl;
7、指向char类型指针

char* str = "hello";
cout<<str<<endl;//hello
cout<<*(str+1)<<endl;//e
cout<<*str<<endl;//h
8、数组与指针

int a[] = {1,2,3,4};
int* p = a;
cout<<*p<<endl; //1
cout<<*(p+2)<<endl;//3


=====================
1、动态分配内存
//堆内存分配空间
//int* p = new int;
//*p = 10;
//上面两句等同与
int* p = new int(10);
cout<<*p<<endl;//4
//引用其他数值
int a = 11;
int* p1 = &a;
cout<<*p1<<endl;

2、释放内存
int* p = new int(10);
cout<<*p<<endl;//10
cout<<p<<endl;//00383EB8
delete p;
cout<<p<<endl;//00383EB8
p = NULL;
cout<<p<<endl;//00000000
3、数组的动态分配内存
int* p = 0; //定义指针
p = new int[20];//分配内存
delete [] p;//释放内存 必须加 []
p = 0;
4、引用与指针
int a = 10;
int &ra = a;
ra +=10;
cout<<ra<<a<<endl; //2020

int b = 10;
int* p = 0;
p = &b;
*p +=10;
cout<<*p<<b<<endl;//2020
5、函数

int add(int,int);//必须在main函数前进行声明

void main(){
int a = 10,b=11;
cout<<add(a,b)<<endl;
}

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

6、传递指针参数
int add(int,int,int*);//必须在main函数前进行声明

void main(){
int a = 10,b=11;
int c = 0;
cout<<add(a,b,&c)<<endl;//21
cout<<c<<endl;//21
}

int add(int a,int b,int* p){
*p = a+b;
return *p;
}

7、传递数组参数
double avg(int a[],int length);//必须在main函数前进行声明

void main(){
int arr[] = {1,2};
cout<<avg(arr,sizeof(arr)/sizeof(arr[0]))<<endl;//1.5 传递数组参数
}

double avg(int a[],int length){
double sum = 0;
for(int i=0;i<length;i++){
sum += a[i];
}
return sum/length;
}

8、传递指针参数
double avg(int*,int);//必须在main函数前进行声明

void main(){
int arr[] = {1,2};
cout<<avg(arr,sizeof(arr)/sizeof(arr[0]))<<endl;//1.5 传递指针参数
}

double avg(int *p,int length){
double sum = 0;
for(int i=0;i<length;i++){
sum += *p++;
}
return sum/length;
}

9、传递引用参数
int add(int,int,int &);//必须在main函数前进行声明

void main(){
int a = 10,b=11;
int c = 0;
cout<<add(a,b,c)<<endl;//21
cout<<c<<endl;//21
}

int add(int a,int b,int &result){
result = a+b;
return a+b;
}
10、main函数的参数
void main(int argc,char* argv[]){
cout<<argc<<endl;
for(int i=0;i<argc;i++){
cout<<argv[i]<<endl;
}
}

======================
1、函数指针
如 double (*p)(double,double);//指向参数为两个double类型并且返回double类型的函数指针；

#include <iostream>
#include <string>
using namespace std;

double sum(double data1,double data2);
void main(int argc,char* argv[]){
/*定义函数指针形式一*/
double (*p)(double,double) = sum; //定义指针并指向sum函数
cout <<p(1.5,2.4)<<endl;//利用函数指针调用函数

/*定义函数指针形式二*/
double (*p1)(double,double) = 0;
p1 = sum;
cout <<p1(1.5,2.4)<<endl;//利用函数指针调用函数
}

double sum(double data1,double data2)
{
return data1+data2;
}
2、异常捕获
try{
throw("error!");
}catch(char message[]){
cout<<message<<endl;//error!
}

3、函数重载

#include <iostream>
#include <string>
using namespace std;

double sum(double data1,double data2);//double类型想加
int sum(int data1,int data2);//int类型想加
void main(int argc,char* argv[]){
cout<<sum(1.3,2.0)<<endl;
cout<<sum(1,2)<<endl;
}

double sum(double data1,double data2)
{
return data1+data2;
}

int sum(int data1,int data2)
{
return data1+data2;
}
4、函数模板

利用函数模板可以替换上述的函数重载

template <typename T> T sum(T data1,T data2){
return data1+data2;
}
void main(int argc,char* argv[]){
cout<<sum(1.3,2.0)<<endl;
cout<<sum(1,2)<<endl;
}

局限性：其实并没有改变程序大小；函数体固定，没有重载可以有不同的函数体的特性；主要用在动态改变实参的场景

5、结构体

结构体定义完后必须有分号！

struct STUDENT{
//string name;//正常
//char name[21];//定义数组大小，正常
//char name[];//会报错
int age;
char name[];//把未分配大小数组放到最后，则正常
};// !!!!必须有分号

void main(int argc,char* argv[]){
STUDENT s1 = {23,"jim"};
cout<<s1.name<<endl;
cout<<s1.age<<endl;
}

6、构造函数初始化
/*
Teacher(string name1,int age1){
name = name1;
age = age1;
cout<<"2参数构造方法被调用"<<endl;
}
*/
Teacher(string name1,int age1):name(name1),age(age1){
//name = name1;
//age = age1;
cout<<"2参数构造方法被调用"<<endl;
}

上述Teachet类的构造函数初始化 是等效的，java中用的是第一种方式，c++多用第二种方式

可以 和java一样用this 则形参和实参名称可以一样

Teacher(string name,int age,string wifeName){
this->name = name;
this->age = age;
this->wifeName = wifeName;
cout<<"2参数构造方法被调用"<<endl;
}


7、获取private成员值
方法一 加入一个返回给该private类型的成员值的public方法；
方式二  用友元函数访问；

/*访问老师类妻子姓名的友元函数*/
class Teacher{
public:
string name;
int age;
Teacher(string name1,int age1,string wifeName1):name(name1),age(age1),wifeName(wifeName1){
cout<<"2参数构造方法被调用"<<endl;
}

string showName(){
return name;
}

private:
string wifeName;

friend void showWifeName(Teacher ct);//定义friend函数
};

//实现friend函数
void showWifeName(Teacher ct){//不能在加上friend
cout<<ct.wifeName<<endl; //lili
}

void main(int argc,char* argv[]){
Teacher t3("jim",23,"lili");
cout<<t3.showName()<<endl;
showWifeName(t3); //调用friend函数
}


java中没有友元类，但内部类有点相似，java一般用方式一实现对private成员的访问。

=====================

1、定义static 成员 并初始化值
class Teacher{
public:
string name;
int age;
//static string sex = "man";//error
static string sex; //定义静态变量
};

string Teacher::sex = "man";//初始化静态变量

java中就简单多了 ，直接初始化就行。不是静态变量java也能直接初始化 如string sex = "man"。

2、静态函数
//定义
static void sayHello(){
cout<<"hello boys"<<endl;
}

//调用
Teacher::sayHello();

3、对象的指针与引用

Teacher t3("jim",23);
Teacher* t4 = &t3; //指针与引用
t4->showName(); //jim

Teacher* t5 = new Teacher("tom",35);//生成新对象
t5->showName();//tom
delete t5;//必须释放内存
t5 = 0; //且指针指向NULL

Teacher& t6 = t3;//对象引用
t6.showName();
4、复制构造函数
？？？

==========
1、union 联合类型

union MyUnion{
int a;
double b;
};

void main(int argc,char* argv[]){
MyUnion mu;
mu.a = 5;
mu.b = 6.9;
cout<<mu.b<<endl;
}

MyUnion类型大小取决于其最大的数据；a，b共享一块数据。
2、预算符重载
class Teacher{
public:
string name;
int age;

Teacher(){
cout<<"默认构造方法被调用"<<endl;
}

Teacher(string name,int age){
this->name = name;
this->age = age;
cout<<"2参数构造方法被调用"<<endl;
}

bool operator > (const Teacher& t)const; //定义预算符重载
};

//实现预算符重载
bool Teacher::operator >(const Teacher& t)const{
return this->age > t.age;
}

void main(int argc,char* argv[]){
Teacher t3("jim",23);
Teacher t4("tom",34);
string result;
(t3>t4)?result="jim 大":result="tom 大";
cout<<result<<endl;
cout<<(t4>t3)<<endl;//1
}
类似于java的equal方法重写，java中equal方法目的是区分对象，原理一样，c++重载运算符也是为了对象间的操作。、

3、三种方式重载运算符 
前两种为类成员函数，第三种为普通函数

#include <iostream>
#include <string>
using namespace std;

class Teacher{
public:
string name;
int age;

Teacher(){
cout<<"默认构造方法被调用"<<endl;
}

Teacher(string name,int age){
this->name = name;
this->age = age;
cout<<"2参数构造方法被调用"<<endl;
}

bool operator > (const Teacher& t)const; //定义预算符重载1
bool operator > (const int& a)const; //定义预算符重载2
};


//实现预算符重载1
bool Teacher::operator >(const Teacher& t)const{
return this->age > t.age;
}

//实现预算符重载2
bool Teacher::operator > (const int& a)const{
return this->age > a;
}

bool operator > (const int& a,const Teacher& t); //定义预算符重载3 为普通函数 不能带const 如bool operator > (const Teacher& t,const int& a)const


void main(int argc,char* argv[]){
Teacher t3("jim",23);
Teacher t4("tom",34);
cout<<"预算符重载1结果："<<(t4>t3)<<endl;//1 等同于(t4.age>t3.age)
cout<<"预算符重载2结果："<<(t3>55)<<endl;//0 等同于(t3.age > 55)
cout<<"预算符重载3结果："<<(t3>55)<<endl;//0 等同于(t3.age > 55)
}

//实现预算符重载3
bool operator > (const int& a,const Teacher& t){
return t.age > a;
}