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、传递
canshu.html" target="_blank">引用参数
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 My
Union{
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;
}
相关文章
