C进阶

最新推荐文章于 2024-06-20 20:32:15 发布
最新推荐文章于 2024-06-20 20:32:15 发布
阅读量209 收藏
点赞数
分类专栏： C++ 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30347421/article/details/108890734
版权

C/C++进阶

C进阶

二级指针+结构体

typedef struct {
    int age;
    char *name;
    char **stdname;
}Teacher;

int  createTeacher(Teacher **res,int num){
    Teacher *T=NULL;
    T=(Teacher * )malloc(sizeof(Teacher)*num);
    memset(T,0,sizeof(T));
    for(int i=0;i<num;i++){
        T[i].name=(char *)malloc(60);
        if(T[i].name==NULL){
            return -1;
        }
        T[i].stdname=(char **)malloc(sizeof(char*)*3);
        for(int k=0;k<3;k++){
            T[i].stdname[k]=(char *)malloc(60);
            if(T[i].stdname[k]==NULL){
                return -1;
            }
        }
    }
    for(int i=0;i<num;i++){
        printf("\nplease enter name:");
        scanf("%s",T[i].name);
        printf("\nplease enter age: ");
        scanf("%d",&(T[i].age));
        printf("\nplease enter std0name:");
        scanf("%s",T[i].stdname[0]);
        printf("\nplease enter std1name:");
        scanf("%s",T[i].stdname[1]);
        printf("\nplease enter std2name:");
        scanf("%s",T[i].stdname[2]);
    }
    *res=T;
    return 0;

}
void freeTeaher(Teacher * T,int num){
    for(int i=0;i<num;i++){
        if(T[i].name!=NULL){
            free(T[i].name);
            T[i].name=NULL;
        }
        if(T[i].stdname!=NULL){
            for(int j=0;j<3;j++){
                if(T[i].stdname[j]!=NULL){
                    free(T[i].stdname[j]);
                    T[i].stdname[j]=NULL;
                }
            }
            free(T[i].stdname);
            T[i].stdname=NULL;
        }

    }
    free(T);
}
int main(){
    Teacher *t=NULL;
    int num=1;
    int ret=createTeacher(&t,num);
    freeTeaher(t,num);
    int cc=1;
    //73

}

C++进阶

三目运算符

#include<iostream>
using namespace  std;
namespace Name{
	int a=10;

}
int main(){
	int a=10;
	int b=20;
	(a<b? a:b)=30;//c++中表达式返回的是变量本身，c语言中表达式返回的是变量的值
	//想当于 10=30;
	//C语言中如何实现C++的效果
	*(a<b? &a:&b)=30;
}

运算符重载

#include<iostream>
using namespace std;


class Point{
public:
Point(int x,int y){X=x;Y=y;}
~Point(){}
Point & operator ++();  //前置操作 
Point operator ++(int); //后置操作
Point & operator --();  //前置操作 
Point operator --(int); //后置操作 
int GetX(){return X;}
int GetY(){return Y;}
private:
int X,Y;
};
Point& Point::operator ++()
{
X++;
Y++;
return *this;
}
Point Point::operator ++(int)
{
Point temp=*this;
++(*this);
return temp;
}
Point& Point::operator --()
{
X--;
Y--;
return *this;
}
Point Point::operator --(int)
{
Point temp=*this;
--(*this);
return temp;
}
int main()
{
Point A(4,6);
cout<<"A的值为:"<<A.GetX()<<","<<A.GetY()<<endl;
A++;
cout<<"A的值为:"<<A.GetX()<<","<<A.GetY()<<endl;
++A;
cout<<"A的值为:"<<A.GetX()<<","<<A.GetY()<<endl;
A--;
cout<<"A的值为:"<<A.GetX()<<","<<A.GetY()<<endl;
--A;
cout<<"A的值为:"<<A.GetX()<<","<<A.GetY()<<endl;
return 0;
}

#include<iostream>
#include<cstring>
using namespace  std;
class Complex{
	public:
	int a;
	int b;
	Complex(int a=0,int b=0){
		this->a=a;
		this->b=b;
	}
	~Complex (){
		cout<<"deconstruct"<<endl;
	}
	friend Complex operator+ ( Complex & c1 ,Complex & c2);
	Complex& operator++(int){
		Complex tmp=* this;
		this->a++;
		this->b++;
		return tmp; 
	}
	Complex operator++(){
		this->a++;
		this->b++;
		return * this;
	}
	friend ostream & operator<<(ostream & out,Complex &c1);
	//complex & operator=(Complex &c1);
};
Complex operator+(Complex & c1,Complex & c2){
	return Complex (c1.a+c2.a,c1.b+c2.b);
}
ostream & operator<<(ostream & out,Complex & c1){
	out<<c1.a<<" "<<c1.b<<endl;
	return out;
}
int main(){
	Complex c1(1,2);
	Complex c2(3,5);
	Complex c3=c1+c2;
	++c1;
	c1++;
	cout<<c1<<c2<<endl;
}

MyArray.h

#pragma once
class MyArray
{	public:
		MyArray(int length);
		~MyArray();
		MyArray(const MyArray& obj);
		void setDate(int idx,int data);
		int getData(int idx);
		int getlength() const;
		int & operator[](int i);
		MyArray& operator=(MyArray & obj);
		bool operator==(MyArray &a1);
private:
	int m_len;
	int* m_data;
};

MyArray.cpp

#include<iostream>
#include "MyArray.h"

MyArray::MyArray(int length) {
	m_len = length;
	m_data = new int[length];

}
int MyArray::getlength()const {
	return m_len;
}
MyArray::MyArray(const MyArray& obj) {
	int len = obj.getlength();
	m_data = new int[len];
	this->m_len = len;
	for (int i = 0; i < len; i++) {
		this->m_data[i] = obj.m_data[i];
	}
}
MyArray::~MyArray() {
	if (m_data != NULL) {
		delete[]m_data;
		m_len = 0;
	}
}
void MyArray::setDate(int idx, int data) {
	m_data[idx] = data;
}
int MyArray::getData(int idx) {
	return m_data[idx];
}
int& MyArray::operator[](int i) {

	return m_data[i];
}
MyArray& MyArray::operator=(MyArray& obj) {
	m_len = obj.m_len;
	if (m_data != NULL) {
		delete[] m_data;
	}
	m_data = new int[m_len];
	for (int i = 0; i < m_len; i++) {
		m_data[i] = obj[i];
	}
	return *this;

}
bool MyArray::operator==(MyArray& a1) {
	if (this->m_len != a1.m_len) {
		return false;
	}
	for (int i = 0; i < m_len; i++) {
		if (m_data[i] != a1[i]) {
			return false;
		}
		return true;
	}
}

main.cpp

#include<iostream>
using namespace  std;
#include "iostream"
using namespace std;
#include"MyArray.h"

int main() {
	MyArray mya(10);
	for (int i = 0; i < 10; i++) {
		mya[i] = i;
	}
	for (int i = 0; i < 10; i++) {
		cout<<mya[i];
	}
	MyArray myb = mya;
	for (int i = 0; i < 10; i++) {
		cout << myb.getData(i);
	}
	MyArray a3(10);
	a3 = mya;
	for (int i = 0; i < 10; i++) {
		cout << a3[i];
	}
	bool res = (mya == a3);
	int cc = 1;
}

MyString类

MyString.cpp

#include "MyString.h"
MyString::MyString() {
    
    m_len = 0;
    m_p = new char[m_len + 1];
    strcpy(m_p, "");

}
MyString::MyString(int len) {

    if (len == 0) {
        m_len = 0;
        m_p = new char[m_len + 1];
        strcpy(m_p, "");
    }
    else {
        m_len = len;
        m_p = new char[m_len + 1];
        memset(m_p, 0, m_len);
    }
    
}
MyString::MyString(const char* p) {
    if (p == NULL) {
        m_len = 0;
        m_p = new char[m_len + 1];
        strcpy(m_p, "");
    }
    else {
        m_len = strlen(p);
        m_p = new char[m_len + 1];
        strcpy(m_p, p);
    }
}
MyString::MyString(const MyString& s) {
    m_len = s.m_len;
    m_p = new char[m_len + 1];
    strcpy(m_p, s.m_p);

}
MyString::~MyString() {
    if (m_p != NULL) {
        delete[] m_p;
        m_p = NULL;
        m_len = 0;
    }
}
MyString& MyString:: operator=(const MyString& obj) {
    if (this->m_p != NULL) {
        delete[] m_p;
        m_len = 0;
    }
    m_len = obj.m_len;
    m_p = new char[m_len + 1];
    strcpy(m_p, obj.m_p);
    return *this;
}
MyString& MyString::operator=(const char* p) {
    if (this->m_p != NULL) {
        delete [] m_p;
        m_len = 0;
    }
    if (p == NULL) {
        m_len = 0;
        m_p = new char[m_len + 1];
        strcpy(m_p, "");
    }
    else {
        m_len = strlen(p);
        m_p = new char[m_len+1];
        strcpy(m_p, p);
    }
    return *this;

}
char& MyString::operator[](int idx) {
    
    return m_p[idx];
}
ostream& operator<<(ostream& out, MyString& s) {
    out << s.m_p;
    return out;
}
bool MyString::operator==(const MyString& obj) {
    if (m_len != obj.m_len) {
        return false;
    }
    return !strcmp(m_p, obj.m_p);
}
bool MyString::operator==(const char* p) {
    if (p == NULL) {
        if (m_len == 0) {
            return true;
        }
        else {
            return false;
        }
    }
    else {
        if (m_len == strlen(p)) {
            return !strcmp(m_p, p);
        }
        else {
            return false;
        }
    }
}
bool MyString::operator!=(const MyString& obj) {
    return !(*this == obj);
}
bool MyString::operator!=(const char* p) {
    return !(*this == p);
}
int MyString::operator<(const char* p) const {
    return strcmp(this->m_p, p);
}
int MyString::operator<(const MyString& s) const {
    return strcmp(this->m_p, s.m_p);
}
int MyString::operator>(const char* p)const {
    return strcmp( p,this->m_p);
}
int MyString::operator>(const MyString& s) const {
    return strcmp(s.m_p,m_p);
}
istream& operator>>(istream& in, MyString& s) {
    cin >> s.m_p;
    return in;
}

MyString.h

#pragma once
#include<iostream>
using namespace std;
class MyString
{
public:
    MyString();
    MyString(int len);
    MyString(const char* p);
    MyString(const MyString& s);
    ~MyString();
    MyString& operator=(const MyString & obj);
    MyString& operator=(const char *p);
    char& operator[](int idx);
    friend ostream& operator<<(ostream & out, MyString & s);
    bool operator==(const MyString & obj);
    bool operator==(const char* p);
    bool operator!=(const MyString& obj);
    bool operator!=(const char* p);

    int operator<(const char *p) const;
    int operator<(const MyString& s) const;
    int operator>(const char *p)const;
    int operator>(const MyString& s) const;
    //把类的指针露出来
    char* c_str() {
        return m_p;
    }
    const char* c_str2() {
        return m_p;
    }
    int length() {
        return m_len;
    }
    friend istream& operator>>(istream & in,MyString & s);
private:
    int m_len;
    char* m_p;
};

main.cpp

#include<iostream>
using namespace  std;
#include"MyString.h"
int main01() {
	MyString s1;
	MyString s2("s2");
	MyString s2_2 = NULL;
	MyString s4 = s2;
	s4 = s2;
	s4 = "2222";
	s4[1] = '3';
	cout << s4;
	int cc = 1;
	return 0;
}
int main() {
	MyString s1;
	MyString s2("s2");
	MyString s3=s2;
	bool res2 = (s2 == "s2");
	bool res = (s2 == s3);
	int res1 = (s2 < "bbb");
	int res3 = (s2 < s3);
	MyString s4 = "123";
	strcpy(s4.c_str(), "124");

	MyString s6(128);
	cin >> s6;
	int cc = 1;
}

编写通讯协议
CSocketProtocol.h

#pragma once
#include<iostream>
using namespace std;
class CSocketProtocol
{
public:
	CSocketProtocol();
	virtual int cltSocketInit() = 0;
	virtual int clsSocketSend( char* buf, int buflen) = 0;
	virtual int cltSocketRev( char* buf, int* buflen) = 0;
	virtual int cltSocketDestroy() = 0;
	virtual ~CSocketProtocol() {  };//虚析构函数的细节
protected:
private:

};

CSocketFactoryImp1.h

#pragma once
#include<iostream>
using namespace std;
#include"CSocketProtocol.h"
class CSocketFactoryImp1:public CSocketProtocol
{
public:
	virtual int cltSocketInit() ;
	virtual int clsSocketSend(char* buf, int buflen) ;
	virtual int cltSocketRev(char* buf, int* buflen) ;
	virtual int cltSocketDestroy();
protected:
private:
	char* p;
	int len;
};

CSocketFactoryImp1.cpp

#include "CSocketFactoryImp1.h"
#include"CSocketProtocol.h"


int CSocketFactoryImp1::cltSocketInit() {
	p = NULL;
	len = 0;

	return 0;
 }
int CSocketFactoryImp1::clsSocketSend(char* buf, int buflen) {
	p = (char*)malloc(sizeof(char) * buflen);
	if (p == NULL) {
		return -1;
	}
	memcpy(p, buf, buflen);
	len = buflen;
	return 0;
 }
int CSocketFactoryImp1::cltSocketRev(char* buf, int* buflen) {
	if (buf == NULL || buflen == NULL) {
		return -1;
	}
	*buflen = this->len;
	memcpy(buf, this->p, this->len);
	return 0;
 }
int CSocketFactoryImp1::cltSocketDestroy() {
	if (p!= NULL) {
		free(p);
		p = NULL;
		len = 0;
	}
	return 0;
 }

main.cpp

#include<iostream>
using namespace  std;
#include"CSocketProtocol.h"
#include"CSocketFactoryImp1.h"

int SckSendAndRec(CSocketProtocol * sp, char * in,int inlen, char * out,int *outlen) {
	int ret = 0;
	ret = sp->cltSocketInit();
	if (ret != 0) {
		goto END;
	}
	ret = sp->clsSocketSend(in, inlen);
	ret = sp->cltSocketRev(out, outlen);
	
END:
	ret = sp->cltSocketDestroy();
	return 0;
}
int main() {
	int ret = 0;
	//sp=new CSckFactoryImpl;
	char in[4096];
	int inlen;
	char out[4096];
	int outlen=0;
	strcpy((char*)in,"aasdsddfdgfgfhghghg");
	strcpy(in,"aaaaaaabbbbaaaaaaaaaa");
	inlen = 9;
	CSocketProtocol* sp = NULL;
	sp = new CSocketFactoryImp1;
	ret=SckSendAndRec(sp, in, inlen, out, &outlen);
	if (ret!= 0) {
		cout << "error" << endl;
		return ret;
	}
	delete sp;
	int cc = 1;
}

模板类派生

#include<iostream>
using namespace  std;
template <class T>
class A {
public:
	A(T t) {
		this->t = t;
	}
	T getA() {

		return this->t;
	}
	void printA() {
		cout << "t" << this->t << endl;
	}
private:
	T t;

};

class B :public A<int> {
public:
	B(int a, int b1):A<int>(a),b(b1){}
private:
	int b;
};
int main() {
	A<int> a1(5);
	B b(5, 3);

	int cc = 1;
	cout << "hello" << endl;
	return 0;

}

模板类继承模板类

#include<iostream>
using namespace  std;
template <class T>
class A {
public:
	A(T t) {
		this->t = t;
	}
	T getA() {

		return this->t;
	}
	void printA() {
		cout << "t" << this->t << endl;
	}
private:
	T t;

};

class B :public A<int> {
public:
	B(int a, int b1):A<int>(a),b(b1){}
private:
	int b;
};
template <class T>
class C :public A<T> {
public:
	C(T c, T a) :A<T>(a) {
		this->c = c;
	}
	void printC() {
		cout << "c:" << c << endl;
	}
protected:
	T c;
};
int main() {
	A<int> a1(5);
	B b(5, 3);
	C<int> c(3, 5);
	c.printC();
	int cc = 1;
	cout << "hello" << endl;
	return 0;

}

单个文件中的类模板

#include<iostream>
using namespace  std;
template <class T>
class Complex {

public:
	Complex(T a, T b);
	Complex operator +(Complex& c2);
	void printCom(); 
	//<T>可加可不加
	friend ostream& operator<<<T>(ostream& out, Complex& c3);
protected:

private:
	T a;
	T b;

};
template <class T>
Complex<T>::Complex(T a, T b) {
	this->a = a;
	this->b = b;
}
template <class T>
void Complex<T>::printCom() {
	cout << "a:" << a << "b" << b << endl;
}
template <class T>
ostream& operator<<(ostream& out, Complex<T>& c3) {
	out << "a:" << c3.a << "b" << c3.b << endl;
}
template <class T>
Complex<T>  Complex<T>::operator +(Complex<T>& c2) {
	Complex tmp(a + c2.a, b + c2.b);
	return tmp;
}
int main() {
	Complex<int> c1(3, 2);
	int cc = 1;
	return 0;
}

多文件模板类

Complexes.h

#pragma once
#include<iostream>
using namespace std;

template <class T>
class Complexes
{	public:
	Complexes(T a, T b);
	Complexes operator +(Complexes& c2);
	void printCom();
	//<T>可加可不加
	friend ostream& operator<<<T>(ostream& out, Complexes& c3);
private:
	T a;
	T b;
};

Complexes.hpp

#include "Complexes.h"


template <class T>
Complexes<T>::Complexes(T a, T b) {
	this->a = a;
	this->b = b;
}
template <class T>
void Complexes<T>::printCom() {
	cout << "a:" <<a << "b" << b << endl;
}
template <class T>
ostream& operator<<(ostream& out, Complexes<T>& c3) {
	out << "a:" << c3.a << "b" << c3.b << endl;
}
template <class T>
Complexes<T>  Complexes<T>::operator +(Complexes<T>& c2) {
	Complexes tmp(a + c2.a, b + c2.b);
	return tmp;
}

main.cpp

#include<iostream>
using namespace  std;
#include"Complexes.hpp";


int main() {
	Complexes<int> c1(3, 2);
	int cc = 1;
	return 0;

}

自定义vector

注意每次先 在这里插入图片描述

MyVector.hpp

#include "MyVector.h"

template<class T>
MyVector<T>::MyVector(int size) {
	m_space = new T[size];
	m_len = size;
}
template<class T>
MyVector<T>::MyVector(const MyVector<T>& obj) {
	m_len = obj.m_len;
	m_space = new T[m_len];
	for (int i = 0; i < m_len; i++) {
		m_space[i] = obj.m_space[i];
	}
	
}
template<class T>
MyVector<T>::~MyVector() {
	if (m_space != NULL) {
		delete[]m_space;
		m_space = NULL;
		m_len = 0;
	}
}
template<class T>
T& MyVector<T>:: operator[](int index) {
	return m_space[index];
}
template<class T>
MyVector<T>& MyVector<T> ::operator=(const MyVector<T>& obj) {
	if (m_space != NULL) {
		delete[] m_space;
		m_space = NULL;
		m_len = 0;
	}
	m_len = obj.m_len;
	m_space = new T[m_len];
	for (int i = 0; i < m_len; i++) {
		m_space[i] = obj.m_space[i];
	}
	return *this;
}
template < class T>
ostream& operator<<(ostream& out, MyVector<T>& obj) {
	for (int i = 0; i < obj.m_len; i++) {
		out << obj.m_space[i] << " ";
	}
	out << endl;
	return out;
}

MyVector.h

#pragma once
#include<iostream>
using namespace std;
template < class T>
class MyVector
{	public:
	MyVector( int size); 

	MyVector(const MyVector& obj);
	~MyVector();
	T& operator[](int index);
	MyVector& operator=(const MyVector& obj);
	int getlen() {
		return m_len;
	}
	friend ostream& operator<<(ostream& out, MyVector& obj);
private:
	int* m_space;
	int m_len;
protected:
};

main.cpp

#include"MyVector.hpp"

int main() {
	int a = 1;
	MyVector<int> myv1(10);
	for (int i = 0; i < myv1.getlen(); i++) {
		myv1[i] = i + 1;
		cout << myv1[i] << " ";
	}
	cout << endl;
	MyVector <int> myv2 = myv1; 
	for (int i = 0; i < myv2.getlen(); i++) {
		myv2[i] = i + 1;
		cout << myv2[i] << " ";
	}
	cout << endl;
	cout<<myv1;
	int cc = 1;
	return 0;
}
qq_30347421
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言进阶篇
Tian_baby的博客
02-22 1万+
B站鹏哥C语言进阶课程笔记。
C语言进阶
qq_65041077的博客
12-03 2226
用户自己定义的可以实现用户需要的功能的函数，使用前如果没有定义需要提前声明。
C语言进阶（详细讲解）
qq_48917201的博客
12-07 1191
一、数据的储存–各个类型的储存方式 1、////介绍空类型–void 的使用 #include <stdio.h> ////介绍空类型--void 的使用 //void test() //{ // printf("hehe\n"); // } // int main() // { // test(); // return 0; // } 2、////大小端查询–写一个程序，判断该机器是大端存储模式还是小端 ////使用指针，，取地址 ////看第一个字节，如果为低位（00）就为大.
C语言进阶（一）
热门推荐
moyu的博客
03-04 1万+
1、内存是线性的。 2、数据类型分类：基本数据类型，构造数据类型。 基本数据类型分为：整型，实型。 整型分为：char,short,int,long int， 实型分为：float,double,long double。 构造数据类型分为：结构体，共用体，数组，枚举，指针，构造类型。 补码 1、同样是1个字节8个位，原码表示数值范围是0-255，补码表示范围是-128-127，这...
C语言基础篇及进阶
Tian_baby的博客
02-22 3080
B站鹏哥C语言学习笔记。
C语言进阶 重点、难点与疑点解析.牟海军.pdf
07-24
该书适合学完c语言基础后使用,里面都是c语言进阶知识,个人认为这是一本很好的c语言进阶书 如果c语言还没有开始学习请先看完c primer plus再看这本书
C语言进阶学习教材
12-17
对于有了一定的C语言基础的编程者来说，这本教材是对C语言进一步研究，进阶课程，能够更好地了解C语言这门语言的魅力
c语言进阶_C语言进阶_源码
10-02
是学习C/C++的学习用书，适合初步了解C/C++的人员使用
C语言进阶、重点、难点与疑点解析 完整版[含目录].pdf
05-05
C语言进阶、重点、难点与疑点解析 完整版,含有目录书签。
嵌入式C语言进阶
10-12
东大凌明讲的很好，C语言的重点要点难点都有讲解，嵌入式C语言
C/C++学习进阶路线
06-16
C/C++学习进阶路线,书籍推荐c++ primer effective C++
C语言进阶（HangMan游戏）
03-18
C语言进阶（HangMan游戏开发），结合数组、指针、函数、文件读写、内存分配、条件分支等多项知识点，C语言提升学习。帮助小白们更好的掌握C语言编程技术。
数据在内存中的存储
h2608011009的博客
04-23 261
文章目录数据在内存中的存储数据类型的介绍整形在内存中的存储浮点型在内存中的存储 数据在内存中的存储 数据类型的介绍 整形： char //字符数据类型（1字节） unsigned char signed char short //短整型（2字节） unsigned short [int] signed short [int] int //整形（4字节） unsigned int signed int long //长整型（4字节） long long //（8字节） unsigned long
C进阶3
weixin_42068537的博客
11-21 312
//---------------------------------------------------- 字符串：有序字符的集合。 C语言中没有字符串的概念，字符串是以“\0”结尾的字符数组。 字符串字面量的本质是一个数组，可以看做常量指针，字符不可改变，至少包含一个字符“\0”. ▲ #include &lt;stdio.h&gt; int main() { char c...
C进阶2
weixin_42068537的博客
11-20 185
enum：可定义真正意义上的常量 sizeof：编译器的内置指示符；用于计算类型或变量所占的内存大小； sizeof 的值在编译期就已经确定,不参与程序的执行。 sizeof（var）或sizeof var；不是函数。 例：int var = 0; int size = sizeof(var++); printf(“var=%d，size = %d\n”,var,size); 结果为：0,4。va...
C语言中编译过程简介
年少轻狂，幸福时光
04-21 404
--事物的难度远远低于对事物的恐惧！      本章节我们来聊一聊编译过程，我们写代码通常会用现成的集成开发环境，比如vs2010等，写完后一键编译，就能获取我们想要的可执行文件，那么在这一键编译的过程中，发生了什么？编译是个怎样的过程？要想了解这个过程，我们首先来了解下编译器。     编译器大概可由如下几个部分组成： 由图我们可以得知，编译器由 预处理器、编译器、汇编器、链接器组成，...
C/C++进阶之进程空间（二）
moyu的博客
03-05 1265
进程空间 首先认识进程和程序的区别 1、程序：源文件经过编译，生成可执行文件，一般window下是*.exe文件，linux下是a.out。程序是静态的。程序包含3个区域，text，inial data, uinial data。 2、进程：被操作系统加载到内存至运行结束的过程。进程是动态的。进程包含5个区域，text，inial data, uinial data，heap，...
C语言中的位域（bit-field）是什么，以及它的用途和优缺点
最新发布
2402_84885073的博客
06-20 340
例如，不同的编译器可能会以不同的方式处理位域的内存布局和对齐。因此，在使用位域时，最好查阅相关编译器和平台的文档，以确保你的代码能够按预期工作。在不同的平台或编译器上，位域的行为可能会有所不同，这导致了位域在本质上是不可移植的。：由于位域不是独立的变量，而是结构体的一部分，因此不能直接对位域进行取地址操作（即不能使用&运算符），这意味着没有能指向位域的指针。位（假设没有内存对齐和填充），但编译器可能会根据内存对齐的要求，在结构体中插入填充字节，以确保结构体的大小是某个特定值（通常是字节的整数倍）的倍数。
c语言进阶高级编程pdf
09-07
《C语言进阶高级编程PDF》是一本以C语言为主题的进阶级别编程书籍，旨在帮助读者提升C语言编程水平并掌握更高级的编程技巧和思维方式。 该PDF书籍的内容包括但不限于以下几个方面： 1. 数据结构与算法：介绍了常用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值